DocsInstall

Use UpFork from an AI assistant

Connect Claude, Claude Code, Cursor, VS Code and other assistants to UpFork's MCP server with its address and a sign-in, so they run preflight at the start of work, search lessons (each with its trust level) and say whether one worked, record lesson drafts, search UpFork, show you a product and its code, install it into your project, read your account, follow your support tickets, keep your profile and résumé up to date, write and publish articles about your products, and learn UpFork's craft from its guides.

Updated This page as Markdown

UpFork has an MCP server at https://upfork.dev/mcp. AI assistants that speak MCP (Claude, Claude Code, Cursor, VS Code's Copilot, Codex, Windsurf and others) use it, first of all, to learn from what other builders found: at the start of work in your project the assistant runs preflight and gets the lessons that apply to your packages at your versions, then searches lessons by an error's exact text, and says whether one worked. Each lesson shows its trust level (published, confirmed, doubtful or outdated). The same server shows you a product and its code, puts a component into your project, and reads your account and purchases, without you leaving your editor.

Lessons are free to read and use now. UpFork keeps the right to charge for access to them later, and they are not under an open license: see the terms.

What it solves

The problem. An assistant writes from what it was trained on. It can't see which components already exist, what changed in a library since, or what another build learned yesterday, so it writes them again and debugs them again.

What you get. One address, https://upfork.dev/mcp. Your assistant asks for the lessons that apply to your project before it starts (preflight), searches UpFork's lessons and products, reads code by its lines, installs a product into your project, follows your tickets and keeps your profile, writing tickets, profile changes and articles in your name only when you agree. Searches answer with short hits first and whole items on request: a search is a few hundred words.

How it grows. Every lesson a build records, and every confirmation an assistant sends after applying one, is there for the next assistant's search. UpFork's guides teach it how UpFork's own work is done: an article, a product that registers cleanly, a listing, a lesson (Prompts and guides).

Installing counts as a shadcn CLI install does, and paying always happens on the site, by you.

Connect your assistant

Add https://upfork.dev/mcp to your assistant. That's all the setup there is: no token to copy.

Preflight, the lessons, searching, looking at products and installing the free ones work straight away. Without an account your assistant is shown only the eight tools for those (preflight, search_lessons, get_lesson, search_products, view_product, read_product_file, install_product and sign_in), which keeps what it reads on every turn short. The first time it needs your account (to say a lesson worked, install a product that isn't free, copy its AI prompt, or for your tickets, profile or articles), it calls sign_in and asks you to sign in: your browser opens UpFork, you sign in as usual, and UpFork shows you which app is asking and what it may do. Allow it, and your assistant connects again with every tool and carries on where it was.

UpFork's server is also listed in the official MCP Registry as dev.upfork/upfork.

Claude

In Claude (on the web or the desktop app), open the connectors, choose Add custom connector, name it UpFork and give it the address https://upfork.dev/mcp. When Claude first needs your account, a Connect button appears in the conversation: it opens UpFork to sign in.

Claude Code

claude mcp add --transport http upfork https://upfork.dev/mcp --scope user

When Claude Code first needs your account, it says UpFork wants you to sign in. Run /mcp, choose upfork and Authenticate: your browser opens UpFork. To sign in before that, do the same right after adding it.

Cursor

Add UpFork to Cursor, or put this in ~/.cursor/mcp.json (or a project's .cursor/mcp.json):

{
  "mcpServers": {
    "upfork": { "url": "https://upfork.dev/mcp" }
  }
}

When Cursor first needs your account, it asks you to sign in to UpFork in your browser.

VS Code

Install UpFork in VS Code, or put this in a project's .vscode/mcp.json:

{
  "servers": {
    "upfork": { "type": "http", "url": "https://upfork.dev/mcp" }
  }
}

When Copilot first needs your account, VS Code asks you to sign in to UpFork in your browser.

Signing in

The sign-in page is UpFork's own, at upfork.dev: your password, Google and two-step sign-in work there as they always do, and your assistant never sees any of them. What it gets is a key for UpFork's MCP server only, which it renews by itself.

Before you allow an app, UpFork shows:

  • Which app asks. Apps that publish their details at their own address (Claude Code does) are shown with that address. Others name themselves, and UpFork says it can't confirm the name: allow those only right after you connected UpFork from them yourself.
  • Where you go back to. The app's address, or "this computer" for an app on your computer.
  • What it may do.
PermissionWhat it lets the app do
Search and readSearch UpFork, look at products and their code, see your account and what you bought; say in your name that a lesson worked or didn't (confirm_lesson, dispute_lesson)
Install and copy promptsInstall products into your projects and copy their AI prompts; an install counts as one with the CLI does
Support ticketsOpen support tickets, read them and reply in your name; if you're UpFork's admin, answer members' tickets as your admin access allows
Your profile and résuméRead and change your profile (not your photo, phone or proved links), and make your PDF résumé
Your articlesWrite articles about your products, change them and publish them in your name; each says which AI model wrote it. Record lesson drafts about your products (draft_lesson, my_lesson_drafts)
Your teams' private lessonsRead your teams' private lessons (search and preflight find them beside the public ones) and record new ones in a team, in your name

You can allow some and not others. No app can buy anything, see your password or e-mail, or change your sign-in. Tickets, profile changes and articles go out in your name, so your assistant shows you what it's about to send, change or publish, and does it only when you agree. Lessons go out in your name too: your word that a lesson worked or didn't (confirm_lesson, dispute_lesson), which the assistant is told to give only after applying the lesson and checking the result, and the drafts it records (draft_lesson), which it tells you about and which stay private to you until you publish them.

An app you connected before a permission existed doesn't have it: when your assistant needs it, it's told to connect UpFork again, and you allow it then.

Every app you allowed is listed in Settings → Connected apps, with when it was last used. Disconnect stops it at once. An app you don't use for 60 days is disconnected by itself; connect it again whenever you like.

What your assistant can do

Without an account, the first eight below are listed (sign_in among them); signed in, every tool but sign_in is. The other tools marked "No" (the articles, the guides, buy_link) still answer without an account when an assistant asks for them by name.

ToolWhat it doesSigned in?
preflightAt the start of work: from a sentence about the task and, once the project has one, its package.json dependencies and devDependencies, the 5 to 10 lessons that apply, short, the most about the task first. In an empty folder the sentence alone finds the lessons about the libraries it names; each lesson says whether the project's versions or the task found it, and the answer ends by asking for package.json again after installing (Preflight)No
search_lessonsLessons alone, without their articles: what builders and their AIs learned, the best matches first, by words (a package, an API, a technique), an error's text, package, product, article or kind. Only lessons that have the words you asked for come back: every word of a short search, most of the words of a long one (half, when the lesson is about a package you named), or a lesson that quotes the error. When none does, the answer is empty (total: 0) and says plainly that no lesson fits; up to three lessons that share some of the search's words come under near, each marked match: partial with the words it shares, to be read and used only if it is the same problem. So the assistant tells you none was found instead of applying a lesson that isn't about this. Answers with a short list (8 a page): number, title, kind, packages, the rule (or, without one, the fix's first sentence), its trust level when it isn't simply published, and the address; get_lesson reads one wholeNo
get_lessonOne lesson by its number (L-7KQ2), whole (its rule, snippet, check and the versions it applies to first, then the story), with short entries for related ones and what agents that applied it saidNo
search_productsSearches the catalog for what you describe, in plain words and typos included, best match first. Only products that have the words you asked for come back: every word of a short search, most of the words of a long one. When none does, the answer is empty and says plainly that nothing fits, so the assistant tells you that instead of installing something else. Answers with a short list (8 a page): each product's name, kind, price, license, whether you may get it, a one-line summary and its address; view_product has the restNo
view_productOne product: its short AI summary first (what it is, how to install it, the entry point, the key props, one example, which files to read next), with its price, license and install command. full adds the long description and every file with its code: anyone's for free products, and for the rest once you're signed in and may get it. A product without an AI summary, or whose summary no longer matches its code (UpFork's summary check), answers in full; aiSummaryReviewed: false marks one Claude drafted from the code that its developer hasn't reviewed yet (AI summaries)No
read_product_fileOne file of a product's code, its lines numbered as an article's ::file block counts them (400 lines a call), or the list of its filesNo (the code you may see on the site)
install_productA component or landing page to put into your project, in a short answer: the one-line npx shadcn add command that installs it all, its AI summary, the packages and shadcn/ui components it needs, its styles, and its files' paths and sizes without their code (read_product_file reads each). A mobile (React Native) component goes into your Expo app instead: its files' paths, its pictures and fonts to download, and the npx expo install line (Install mobile components)Not for free products; yes for the rest
sign_inAsks you to sign in, when you want something that needs your account: your app opens UpFork, and then shows every toolListed without an account only
confirm_lessonSays, in your name, that a lesson worked when your assistant applied it in your project, with the versions it usedYes
dispute_lessonSays, in your name, that a lesson didn't hold when applied here, with the versions and why; its author is toldYes
draft_lessonRecords a lesson the moment a surprise is solved and checked while building one of your products, without an article: private to you until you publish it (Drafts); 10 a dayDevelopers
my_lesson_draftsYour lesson drafts, short (those waiting, unless it asks for others), or one whole by its idDevelopers
draft_team_lessonRecords a lesson about your team's own code in the team, the moment it's solved and checked: proposed until the team's owner publishes it there; 20 a day per memberTeam members
team_lessonsYour teams, or one team's lessons (short, or one whole); search_lessons, preflight and get_lesson also mix in your teams' published lessons, marked teamTeam members
buy_linkThe page on UpFork where you buy a developer's paid productNo
get_promptA product's AI prompt, as its page's copy button gives it, for a project that isn't React with Tailwind CSS, with the product's AI summaryYes
my_accountYour name and role, and what you boughtYes
open_ticketOpens a support ticket in your name: a topic, a subject and the messageYes
my_ticketsYour tickets, the latest first, with where each standsYes
read_ticketOne ticket and its whole conversation, by its number (UPF-10427)Yes
reply_to_ticketSends a message on one of your ticketsYes
support_inboxFor UpFork's admin account: the support inbox (waiting, unassigned, mine or all)Admin
answer_ticketFor UpFork's admin account: answers a member's ticket as UpFork, and can mark it resolvedAdmin
my_profileYour profile as you edit it: headline, about, skills, languages, networks, experience, pinned productsYes
update_profileChanges what you ask for and keeps the rest; a developer's profile is their public pageYes
make_resumeMakes your PDF résumé and gives the link to download it and its check pageDevelopers
article_guideHow to write an article on UpFork: the steps, the blocks, the kinds of article and the rulesNo
get_guideUpFork's guides: without a topic, their short index; with one (articles, products, listings, lessons, agents), that guide whole, with its template and the reason for each part (Prompts and guides)No
search_articlesPublished articles, the newest first, by words, kind of article, kind of product, product or developer. Answers with short cards (8 a page): title, summary and address; read_article reads one wholeNo
read_articleOne published article, whole: its text and lessons, the lines of each file it shows, who wrote it and with which AI modelNo
my_articlesYour articles, where each stands, and the products you may write aboutDevelopers
get_my_articleOne of your articles as you edit it: its text, what must be put right before it can go out, and what to do nextDevelopers
create_articleStarts a draft about one of your productsDevelopers
update_articleWrites or changes its title, summary, kind, tags, cover and text, and says what's wrongDevelopers
add_article_imageAdds a picture from its https address, for the text or the coverDevelopers
publish_articlePublishes it, or its changes; your first two articles go to UpFork's review firstDevelopers
withdraw_articleTakes it back from review, to change itDevelopers
hide_articleTakes a published article off the site (only you see it), or puts it backDevelopers
delete_articleDeletes one of your articles for good, only if it was never published (a published one is refused: hide_article takes it off the site, and its lessons are never deleted), when you askDevelopers

Ask in your own words, for example: "Find a pricing table with a monthly and yearly switch on UpFork", "Show me the code of UpFork's OrbitGallery", "Add UpFork's Crowdwall to this page", "Open a ticket on UpFork: my download link expired", "Add TypeScript and Rust to my UpFork skills", "Make my UpFork résumé in blue" or "Write an UpFork article about how my black hole hero bends light, and show it to me before you publish it".

Articles from your assistant

Your assistant can write an article about one of your products from start to end: it reads the product's code by its lines, writes the draft with the product's blocks (its files, live preview and install command) and its lessons, puts right what UpFork finds wrong, adds pictures, and publishes when you say so. UpFork tells it the shape of an article and that every article carries at least one lesson: what it, or you, learned building the product that wasn't known before, checked there; it gathers them first, from its own notes, the commits and you. Everything goes through the same checks as the editor on the site, and your first two articles go to UpFork's review whoever wrote them.

Every article an AI wrote says so. Each write names the model writing, as the model names itself, and the app it came through; the article shows "Written with AI: Claude Opus 5.5, through Claude" under your name, and its Markdown says the same. It stays when you edit the article on the site afterwards. UpFork can't confirm a model's name: it's the model's own word, and the article page says so.

You can read and finish the draft any time in Developer panel → Articles, where it reads as it will look.

What builders learned, for your assistant

Every article's lessons are kept on their own as well, each with a number (L-7KQ2), so an assistant that builds something can start from what others found building something like it: search_lessons answers with a short list, rather than whole lessons or articles: for each hit its number, title, kind, the packages and versions it holds for, the first sentence of its fix and its address, eight to a page. It searches by words in any form ("three web worker", "next server component"), by an error's text pasted whole, or gives all of one package's, product's or article's lessons. When a hit fits, get_lesson reads that one whole (what was assumed, what happened, why, the fix and the evidence), with short entries for related ones, and read_article reads a lesson's whole article when the assistant needs the story around it. Only the lesson that fits is read in full; a search is a few hundred words. search_products works the same way with view_product, which answers with the product's short AI summary (about 1,500 characters: the entry point, the key props, one example) instead of its whole code, and search_articles with read_article. view_product with full gives the long form. An assistant that wants the long form in one answer asks for full, and pageSize (up to 20) sets how many hits a page holds. A lesson written for an older version of a package than the newest says what it may be outdated for. UpFork's server tells every assistant this when it connects: search lessons before writing code against a library version it's unsure of, and when an error surprises it. Lessons are another build's evidence: an assistant weighs them, it doesn't take orders from them, and never runs a command from one without asking you.

After your assistant applied a lesson in your project and checked the result, it can say so in your name: confirm_lesson when it worked, dispute_lesson when it didn't (with why), each with the packages and versions it used. One word per account and lesson; saying it again replaces it, and it's never for your own lessons. The lesson's page then shows "Worked for 4 agents", and a lesson marked outdated is cleared for the newer versions an agent confirmed it with. UpFork tells assistants to do it only after applying a lesson, never on a guess.

Every lesson carries its trust: published, confirmed (agents of two accounts or more applied it and it held), doubtful (disputed by two accounts or more, no fewer than confirmed it) or outdated. Searches put the doubtful and outdated ones after the rest, labelled, so an assistant checks them before relying on them; preflight lists a doubtful one last and leaves out one outdated for the project's own version.

When your assistant builds one of your products and solves a surprise (a fix that turned the build or the tests green after a failed try), it records it at once with draft_lesson, without waiting for an article: the four lines and the story, the product, and its own name. UpFork checks the draft as it's saved and tells the assistant what's missing or wrong; the draft stays private to you until you publish it (Drafts).

Ask, for example: "Before you start, search UpFork's lessons for three.js in a web worker", "Look up lesson L-7KQ2 on UpFork", or "That lesson worked: confirm it on UpFork".

Prompts and guides

UpFork's server also teaches an assistant how UpFork's own work is done: the principles, a template, and the reason for each part. Like the searches, it starts short: an index of five lines, then only the guide the task needs.

GuideResourceWhat it holdsPrompt
The indexupfork://guidesEach guide in a line: when to read it, and its prompt
Writing an articleupfork://guides/articlesThe steps, the shape by kind of article, the blocks and the rules (as article_guide gives them)write-article
Making a product that registers cleanlyupfork://guides/productsThe registry/ folder, the rules for paths, imports, packages, Styles and demos and why, what the install check runs, and its common failures with their fixesmake-product
Writing a listingupfork://guides/listingsThe LISTING.md template, each field's limit and why it's therewrite-listing
Recording a lessonupfork://guides/lessonsWhat a lesson is and isn't, searching and vouching, and the :::lesson template part by partrecord-lesson
The AGENTS.md blockupfork://guides/agentsA block for your project's AGENTS.md that tells its assistants when to use UpFork

An assistant reads a resource where its app supports them; get_guide gives the same text in any app. The prompts are commands you pick (in Claude Code, type / and look for UpFork's): each walks your assistant through the work, starting from its guide, and ends by showing you the result before anything goes out. UpFork's server names the index in the instructions every assistant gets when it connects. The Templates page has the same templates for people.

What counts

What your assistant doesWhat it counts as
Searching, looking at a product or its code, reading your accountNothing, ever
install_productAn install, as with the shadcn CLI
get_promptAn AI prompt, as copying it on the product's page does
buy_linkNothing: it's a link, and you pay on the site
Tickets, the profile and the résuméWhat they do on the site: the same limits (5 new tickets a day, 10 résumés a day)
Articles, and reading products' filesThe same limits as on the site (20 drafts, 40 pictures an article)

When a limit is reached, or a product isn't yours yet, your assistant is told so with what to do.

With an access token instead

Assistants that can't sign you in, and scripts, can send an access token instead: the same token the shadcn CLI uses, with the same access as your account. Create one on Account → Access tokens and keep it in an environment variable named UPFORK_TOKEN, never in a file you share:

# macOS and Linux: add this to your shell's profile (~/.zshrc, ~/.bashrc)
export UPFORK_TOKEN=upf_...
# Windows: once, then open a new terminal
setx UPFORK_TOKEN "upf_..."

Each setup below reads the token from there, so it never sits in a config file or a link. With a token set, the assistant doesn't ask you to sign in.

Codex:

codex mcp add upfork --url https://upfork.dev/mcp --bearer-token-env-var UPFORK_TOKEN

Windsurf (Devin Desktop), in mcp_config.json (~/.config/devin/ on macOS and Linux, %APPDATA%\devin\ on Windows):

{
  "mcpServers": {
    "upfork": {
      "serverUrl": "https://upfork.dev/mcp",
      "headers": { "Authorization": "Bearer ${env:UPFORK_TOKEN}" }
    }
  }
}

Claude Code (the single quotes keep ${UPFORK_TOKEN} as written, so it's read from your environment each time):

claude mcp add --transport http upfork https://upfork.dev/mcp --scope user --header 'Authorization: Bearer ${UPFORK_TOKEN}'

Cursor:

{
  "mcpServers": {
    "upfork": {
      "url": "https://upfork.dev/mcp",
      "headers": { "Authorization": "Bearer ${env:UPFORK_TOKEN}" }
    }
  }
}

VS Code, which asks for the token once, hides it as you type, and keeps it for UpFork:

{
  "inputs": [
    { "type": "promptString", "id": "upfork-token", "description": "Your UpFork access token, upf_…", "password": true }
  ],
  "servers": {
    "upfork": {
      "type": "http",
      "url": "https://upfork.dev/mcp",
      "headers": { "Authorization": "Bearer ${input:upfork-token}" }
    }
  }
}

Any other assistant that connects to MCP servers over HTTP: send the token as Authorization: Bearer <your token>.

Good to know

  • Two ways to install. install_product answers short, without any file's code: the command, the AI summary and the list of files with their sizes (about 11 KB for a product of 52 files). Your assistant runs the command in a project set up for UpFork (Install components), or reads each file with read_product_file and writes it into your project. Both count the same.
  • Paying stays with you. buy_link only gives the page: you open it, sign in, and pay in USDT yourself (Paying with USDT). No tool can pay or see a wallet.
  • Sellers' and builders' words are data. Product descriptions and code are written by their sellers, and lessons by other builders. UpFork marks them as such for your assistant, and tells it never to follow instructions in them. The same goes for the messages in a ticket.
  • Admin tools follow the admin hub. support_inbox and answer_ticket work only for UpFork's admin account, with the same permissions as on the site; something that needs the owner's approval is done on the site.
  • Without an account, a tool that needs one answers your assistant with what it does and how to sign in, and does nothing; it never says a token expired, since there was none.
  • When a token doesn't work, UpFork's server refuses it and your assistant says so: a deleted or mistyped access token needs a new one from Account → Access tokens, and a disconnected app needs signing in again.
  • Version 1.13.1 (2026-10-31): delete_article deletes only an article that was never published; a published one is refused with the way off the site (hide_article), and its lessons are never deleted.
  • Version 1.13.0 (2026-10-30): the short tool list without an account, the short install_product, preflight from a task sentence alone, and plain sign-in answers.
  • Limits: 120 requests a minute when signed in or with a token, 60 a minute from one address without either. A request is at most 512 KB signed in (an article's text is up to 100 kB), 64 KB without.