# 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, to search UpFork, show you a product and its code, install it into your project, and read your plan.

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) can use it to search UpFork for what you describe, show you a product and its code, put a
component into your project, and read your plan and purchases, without you leaving your editor.

Looking never counts against your plan. 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.

Searching and looking at products work straight away. The first time your assistant needs your account (to install a
product, copy its AI prompt or read your plan), it 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 carries on where it was.

## 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

```bash
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](cursor://anysphere.cursor-deeplink/mcp/install?name=upfork&config=eyJ1cmwiOiJodHRwczovL3VwZm9yay5kZXYvbWNwIn0=), or put this in `~/.cursor/mcp.json` (or a project's `.cursor/mcp.json`):

```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](vscode:mcp/install?%7B%22name%22%3A%22upfork%22%2C%22type%22%3A%22http%22%2C%22url%22%3A%22https%3A%2F%2Fupfork.dev%2Fmcp%22%7D), or put this in a project's `.vscode/mcp.json`:

```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 plan and what you bought |
| Install and copy prompts | Install products into your projects and copy their AI prompts, which count against your plan as the CLI's installs do |

No app can buy anything, see your password or change your account.

Every app you allowed is listed in [Settings → Connected apps](https://upfork.dev/account/settings#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

| Tool | What it does | Signed in? |
| --- | --- | --- |
| `search_products` | Searches the catalog for what you describe, in plain words and typos included, best match first, with each product's price, license and whether you may get it | No |
| `view_product` | One product: its description, price and license, and for components and landing pages its files and install command (the code itself once you're signed in) | No |
| `buy_link` | The page on UpFork where you buy a product or a plan | No |
| `install_product` | A component or landing page to put into your project: its files and where they go, the packages and shadcn/ui components it needs, its styles, and the `npx shadcn add` command | Yes |
| `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 | Yes |
| `my_account` | Your plan and until when, what's left of its limits today, and what you bought | Yes |

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"*, or *"Add UpFork's Crowdwall to this page"*.

## 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: for UpFork's products that come with a plan, a download off your plan |
| `get_prompt` | An AI prompt on your plan, as copying it on the product's page does |
| `buy_link` | Nothing: it's a link, and you pay on the site |

The same product counts once a day for each, however often your assistant asks. When a limit is reached, or a
product isn't yours yet, your assistant is told so with what to do, and the [pricing page](https://upfork.dev/pricing) has the plans.

## 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](https://upfork.dev/account/tokens) and keep it in an
environment variable named `UPFORK_TOKEN`, never in a file you share:

```bash
# macOS and Linux: add this to your shell's profile (~/.zshrc, ~/.bashrc)
export UPFORK_TOKEN=upf_...
```

```powershell
# 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:**

```bash
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):

```json
{
  "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):

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

**Cursor:**

```json
{
  "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:

```json
{
  "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.** Your assistant can write the files `install_product` gives it straight into your project,
  or run the install command in a project set up for UpFork ([Install components](https://upfork.dev/docs/install)). 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](https://upfork.dev/docs/paying)). No tool can pay or see a wallet.
- **Sellers' words are data.** Product descriptions and code are written by their sellers. UpFork marks them as such
  for your assistant, and tells it never to follow instructions in them.
- **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](https://upfork.dev/account/tokens), and a disconnected app needs signing in again.
- **Limits:** 120 requests a minute when signed in or with a token, 60 a minute from one address without either.

Page: https://upfork.dev/docs/mcp