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 userWhen 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.
| Permission | What it lets the app do |
|---|---|
| Search and read | Search 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 prompts | Install products into your projects and copy their AI prompts; an install counts as one with the CLI does |
| Support tickets | Open 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 articles | Write 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 lessons | Read 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.
| Tool | What it does | Signed in? |
|---|---|---|
preflight | At 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_lessons | Lessons 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 whole | No |
get_lesson | One 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 said | No |
search_products | Searches 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 rest | No |
view_product | One 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_file | One 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 files | No (the code you may see on the site) |
install_product | A 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_in | Asks you to sign in, when you want something that needs your account: your app opens UpFork, and then shows every tool | Listed without an account only |
confirm_lesson | Says, in your name, that a lesson worked when your assistant applied it in your project, with the versions it used | Yes |
dispute_lesson | Says, in your name, that a lesson didn't hold when applied here, with the versions and why; its author is told | Yes |
draft_lesson | Records 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 day | Developers |
my_lesson_drafts | Your lesson drafts, short (those waiting, unless it asks for others), or one whole by its id | Developers |
draft_team_lesson | Records 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 member | Team members |
team_lessons | Your teams, or one team's lessons (short, or one whole); search_lessons, preflight and get_lesson also mix in your teams' published lessons, marked team | Team members |
buy_link | The page on UpFork where you buy a developer's paid product | No |
get_prompt | A 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 summary | Yes |
my_account | Your name and role, and what you bought | Yes |
open_ticket | Opens a support ticket in your name: a topic, a subject and the message | Yes |
my_tickets | Your tickets, the latest first, with where each stands | Yes |
read_ticket | One ticket and its whole conversation, by its number (UPF-10427) | Yes |
reply_to_ticket | Sends a message on one of your tickets | Yes |
support_inbox | For UpFork's admin account: the support inbox (waiting, unassigned, mine or all) | Admin |
answer_ticket | For UpFork's admin account: answers a member's ticket as UpFork, and can mark it resolved | Admin |
my_profile | Your profile as you edit it: headline, about, skills, languages, networks, experience, pinned products | Yes |
update_profile | Changes what you ask for and keeps the rest; a developer's profile is their public page | Yes |
make_resume | Makes your PDF résumé and gives the link to download it and its check page | Developers |
article_guide | How to write an article on UpFork: the steps, the blocks, the kinds of article and the rules | No |
get_guide | UpFork'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_articles | Published 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 whole | No |
read_article | One published article, whole: its text and lessons, the lines of each file it shows, who wrote it and with which AI model | No |
my_articles | Your articles, where each stands, and the products you may write about | Developers |
get_my_article | One of your articles as you edit it: its text, what must be put right before it can go out, and what to do next | Developers |
create_article | Starts a draft about one of your products | Developers |
update_article | Writes or changes its title, summary, kind, tags, cover and text, and says what's wrong | Developers |
add_article_image | Adds a picture from its https address, for the text or the cover | Developers |
publish_article | Publishes it, or its changes; your first two articles go to UpFork's review first | Developers |
withdraw_article | Takes it back from review, to change it | Developers |
hide_article | Takes a published article off the site (only you see it), or puts it back | Developers |
delete_article | Deletes 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 ask | Developers |
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.
| Guide | Resource | What it holds | Prompt |
|---|---|---|---|
| The index | upfork://guides | Each guide in a line: when to read it, and its prompt | |
| Writing an article | upfork://guides/articles | The steps, the shape by kind of article, the blocks and the rules (as article_guide gives them) | write-article |
| Making a product that registers cleanly | upfork://guides/products | The registry/ folder, the rules for paths, imports, packages, Styles and demos and why, what the install check runs, and its common failures with their fixes | make-product |
| Writing a listing | upfork://guides/listings | The LISTING.md template, each field's limit and why it's there | write-listing |
| Recording a lesson | upfork://guides/lessons | What a lesson is and isn't, searching and vouching, and the :::lesson template part by part | record-lesson |
| The AGENTS.md block | upfork://guides/agents | A 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 does | What it counts as |
|---|---|
| Searching, looking at a product or its code, reading your account | Nothing, ever |
install_product | An install, as with the shadcn CLI |
get_prompt | An AI prompt, as copying it on the product's page does |
buy_link | Nothing: 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' files | The 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_TOKENWindsurf (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_productanswers 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 withread_product_fileand writes it into your project. Both count the same. - Paying stays with you.
buy_linkonly 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_inboxandanswer_ticketwork 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_articledeletes 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,preflightfrom 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.