Upwork MCP in Claude Code: Official Server + Job Feed Setup

On 10 August 2026, Upwork shipped an official MCP server at mcp.upwork.com/mcp. It is free, it uses OAuth, and it is genuinely good: your agent can search jobs, draft a proposal grounded in your profile, submit it, spend the Connects, and manage the contract afterwards.

It has one gap, and it is a deliberate one. Nothing tells it when to act.

MCP is request and response. A server cannot reach into your editor and wake you up, and Upwork's terms are explicit that their tools are not to be used to continuously monitor the marketplace. So the official server will do anything you ask, the moment you ask, and nothing at all in between. It is a hand, not an eye.

That is the half this post fills in. You run two MCP servers side by side: Vibeworker watches the marketplace and ranks what appears, Upwork's own server does the writing and the submitting. Setup is two commands.

What each server is for

	Vibeworker MCP	Official Upwork MCP
Tells you a job exists	Yes, push notification or webhook the moment it lands	No, you have to ask
Ranks against your profile	Yes, per-user match score	No, Upwork's own recommendations
Remembers what you've seen	Yes	No
Full job context for drafting	Yes	Yes
Drafts a proposal	Your agent does, from our context payload	Yes, grounded in your Upwork profile
Submits the proposal	No, never	Yes, after you confirm
Manages contracts, messages, milestones	No	Yes
Cost	Free with any paid Vibeworker plan, free preview available	Free, standard Connects apply

The overlap is small and the split is clean. We never touch Upwork on your behalf. Upwork never watches the feed for you.

Setup

Nothing to install for either one. Both are hosted, so you point your client at a URL.

Upwork's official server authenticates with OAuth, so there is no key to paste:

claude mcp add --transport http upwork https://mcp.upwork.com/mcp

Then run /mcp in a Claude Code session to finish the login in your browser.

Vibeworker uses an API key. Sign up, generate one under Settings → Developer, and it looks like vw_...:

claude mcp add vibeworker https://tryvibeworker.com/api/mcp \
  --header "Authorization: Bearer vw_your_api_key"

Cursor, Windsurf, or any other MCP client take the same two servers as config:

{
  "mcpServers": {
    "upwork": {
      "url": "https://mcp.upwork.com/mcp"
    },
    "vibeworker": {
      "url": "https://tryvibeworker.com/api/mcp",
      "headers": {
        "Authorization": "Bearer vw_your_api_key"
      }
    }
  }
}

That's it. Restart your client and both tool sets show up.

The first thing to ask

What Upwork jobs match my profile right now?

Claude calls list_jobs and comes back with something like:

1. [vw_b797267068b2] Build a Next.js dashboard with Supabase backend
   Fixed · $800 | Match: 91% | QuickWin: 8/10
   Web Development · https://www.upwork.com/jobs/~01abc...

2. [vw_2f10ac4491de] Fix broken Stripe webhook handler on a live store
   Fixed · $250 | Match: 88% | QuickWin: 9/10
   Web Development · https://www.upwork.com/jobs/~01def...

Two numbers there aren't in a raw job feed. Match is how well the job fits your profile, computed per-user. QuickWin is an LLM's read on whether the job is fixed-price, clearly bounded, and finishable in one session, the fastest path to a completed contract when you're building reviews.

If your profile isn't set up yet, say so and ask Claude to handle it. update_profile is one of the tools, so it can write your profile text and pick a scoring mode without you opening the dashboard.

Filtering in the prompt, not the UI

list_jobs takes real parameters, which means you can filter conversationally:

Show me fixed-price jobs over $500, sorted by quick win.

Behind that: jobType: "Fixed", minBudget: 500, sort: "quick_win". The full set is limit, sort (match, newest, budget, quick_win), jobType, minBudget, minScore, and categories.

minScore is the one people miss. It's your match score as a 0–1 float, so minScore: 0.8 means "only the top fifth of what you'd normally see." Useful when you want the shortlist rather than the feed.

For keyword hunting across recent postings, search_jobs searches titles and descriptions directly.

Everything so far is one half of the split: working out which jobs are worth your Connects. The Upwork server picks up from there.

Draft here, submit there

The reason to run this inside an AI assistant rather than a dashboard is that reading is only step one. Ask:

Draft a proposal for the Stripe one.

Claude calls get_proposal_context, which returns the full job description, the client's history, your profile, and a set of writing instructions in a single payload. Then it drafts, natively, with everything it needs already in context.

The instructions that come back are opinionated on purpose: under 200 words, lead with the client's problem rather than your credentials, reference concrete details from the brief, end with one question that proves you read it. That's the shape that actually gets replies.

Then, in the same session:

Submit that through Upwork.

The official server takes it from there. Every write action is drafted first and confirmed separately, so you see exactly what is about to be sent and what it costs in Connects before anything happens. Vibeworker still never touches Upwork on your behalf and still doesn't automate submission. That has always been the line here, and it matters. The difference now is that Upwork built the other side of it themselves, officially and for free, so you no longer have to leave the editor to finish the job.

Keep your hand on that confirmation. Upwork's terms prohibit an agent taking a consequential action without your specific direction on the specific job, and their own docs are blunt about it: no agent applies on your behalf without you. A setup that fires off proposals unattended isn't a clever workaround, it's a good way to burn Connects on jobs you'd never have picked.

A useful morning routine

The chained version is where this gets genuinely faster than the dashboard:

Check my feed, pick the three best fixed-price jobs under 10 hours
of estimated effort, and draft proposals for all of them.

That's list_jobs → get_job three times → get_proposal_context three times, with judgment applied in between. You come back to three drafts. Read them, kill the one that misread the brief, and submit the other two through the Upwork server without opening a browser tab.

Ten minutes of work, most of which is you editing rather than searching.

Worth adding to your CLAUDE.md if you do it daily:

## Upwork workflow
Job discovery and ranking: vibeworker MCP tools.
Submitting, messaging, contracts: official upwork MCP tools.

Prefer fixed-price work under 15 estimated hours.
Never draft a proposal without calling get_proposal_context first.
Always show me the draft and the Connects cost before submitting.
Never submit anything I have not explicitly approved in this session.

That last line is worth keeping even though Upwork enforces confirmation server-side. Belt and braces, and it stops the agent volunteering.

"Why not just ask Upwork's server?"

Fair question, and worth asking before you pay for anything. Upwork's MCP searches jobs. You could open a session a few times a day, ask what's new, and skip the second server entirely.

For answering "what's on the marketplace right now," that is exactly the right tool and you should use it that way. It just isn't built for the other question, which is "did anything worth my time appear while I wasn't looking." Nothing in a request-and-response protocol can be.

Four things happen when you ask it to do that second job anyway.

There's no "since last time." Their server holds no memory between sessions, so every check returns whatever currently matches, not what's appeared since you last looked. Check three times in a day and you re-read the same twenty jobs twice. The more diligently you check, the more of your reading is repeats. A habit that punishes you for keeping it is a habit you drop in a fortnight.

The ranking is Upwork's ranking. It ranks for the marketplace as a whole, which is the correct thing for a marketplace to do. It has no view of the jobs you dismissed last week, the clients you have decided to avoid, or the rate you stopped going below. That isn't a flaw in their search, it's a different job.

Five checks a day averages two and a half hours late, and much worse overnight. Proposals sent in the first hour get read. No amount of discipline gets manual checking inside that window, because the window opens when the client posts, not when you remember.

You have to remember. That's the part nobody budgets for. Checking isn't the work and never feels like work, but it sits in your head all day and it's the reason people describe job hunting as exhausting rather than time-consuming.

None of that is a knock on their server. It does what it was built for, well and for free. Watching the marketplace on your behalf was never the thing it was built for.

Where the trigger comes from

Everything above still starts with you opening a session. The part that makes this feel like automation rather than a faster dashboard is the notification.

Vibeworker fires when a job matching one of your filter presets lands, by push, email, Telegram, Discord, or webhook. That's the signal that a session is worth opening, and it's the piece an MCP server structurally cannot provide: it can only answer, never interrupt.

Set the presets once, in the dashboard or by asking Claude to configure them, and the feed comes to you.

Limits

MCP access is included free with any paid Vibeworker plan, with no per-call charge and no separate add-on. If you're not subscribed there's a free preview: 25 job results to try it with, then continued access to jobs older than 24 hours.

That shape is deliberate rather than arbitrary. A job posting's value decays fast, proposals sent in the first hour get read, and by the time a post is a day old the client is already working a shortlist. The preview shows you the whole system working, just not the window where it wins you contracts.

The configuration tools are the exception: create_filter, update_filter, update_profile and the rest are never rate-limited on any plan. Letting Claude set up your account costs nothing regardless of what you're paying.

Upwork's server has no subscription fee at all. You pay in Connects, at the same rate as the website.

Two halves of one workflow

Something has to notice, and something has to act.

Upwork built the half that acts, and built it properly: official, free, tied to your real account, your confirmation on every write, your money never leaving their escrow. Nobody else could have built that half. Now that it exists, there's no good reason to be pasting proposals into a browser tab.

We build the half that notices. Watching the marketplace, learning which jobs are worth your Connects, and telling you the moment one lands. That was never Upwork's job, and we've never wanted theirs. We're not competing with the marketplace, we're trying to help you win on it.

Upwork built the hand. This is the eye.

Run both and the loop closes. A notification arrives, you open a session, one server tells you what landed and why it's worth your attention, the other writes it up and sends it. The only part left is the part that should be yours: deciding whether to say yes.

The configuration side is the half most people don't expect. The same connection that reads your feed can rebuild it, and that's worth its own post.

If you'd rather build against plain HTTP than MCP, the API quickstart covers the same data from curl, Node, or Python.

Full MCP reference and tool list →