Pocketsflow MCP Setup for Cursor: Sell from Your Code Editor

To set up Pocketsflow MCP in Cursor, add the hosted server https://api.pocketsflow.com/mcp to your .cursor/mcp.json with an Authorization: Bearer pk_live_... header using an API key from Developers in your Pocketsflow dashboard, restart Cursor, and prompt “list my Pocketsflow products” to verify. Cursor then gets 53 tools for products, checkout, discounts, orders, refunds, subscriptions, and more, all scoped to that key. Setup takes about five minutes, and your first product can be live without leaving your editor.

What Cursor plus Pocketsflow actually gives you

Cursor is already where you build: files, terminal, and an AI assistant that can read your whole repo. Adding Pocketsflow as an MCP server turns that editor into a storefront manager. You describe the outcome in plain words and Cursor picks the right API calls over HTTP transport with your Bearer key.

Say “create a $49 one-time product called Pro license with a 20% launch discount and give me the checkout link” and Cursor chains create_product to create_discount to create_checkout_session. Every action shows up in your dashboard at app.pocketsflow.com exactly as if you had clicked it by hand. If you started with the chat-first path, our guide to connecting Pocketsflow to Claude via MCP covers the general concepts; this post is the Cursor-native version for sellers who live in the editor.

What you need before you start

You need exactly three things:

• A Pocketsflow account. Selling has no monthly fee—each sale carries one estimated itemized transaction cost of 4.7% + $0.30 (about $5.00 on a $100 sale), shown line by line on every order.
• Cursor installed with MCP support enabled. Any recent version works; update first if you do not see an MCP section in settings.
• An API key from your dashboard at app.pocketsflow.com under Developers. Use a pk_test_ key while learning and a pk_live_ key for real money—test mode never touches real customers.

The hosted server address is always https://api.pocketsflow.com/mcp. That is a connector address for your MCP client, not a web page you visit. Full protocol details live in the Pocketsflow MCP server reference.

Step 1: Create an API key with the right scope

Open your Pocketsflow dashboard, go to Developers, and create a new API key. Give it a name you will recognize in six months, like “cursor-editor”. Copy the full key once—you cannot see it again later.

Scope matters because the MCP server can do everything the key can do and nothing more. A live key creates real products, real checkouts, and real charges. A test key does all the same things against sandbox data. Start with pk_test_, prove your workflow end to end, then repeat the setup below with pk_live_ when you are ready to sell. Keep keys out of screenshots, committed dotfiles, and chat transcripts, and rotate a key the moment you suspect it leaked.

Test versus live, in one rule

If the key starts with pk_test_, nothing the agent does can charge anyone. If it starts with pk_live_, everything is real. Never mix them in the same Cursor session, and say which mode you are in out loud in your first prompt so the transcript is unambiguous.

Step 2: Add Pocketsflow to Cursor

Cursor stores MCP servers in .cursor/mcp.json, either at your project root for a per-project setup or in your Cursor user config for a global setup. Use the project file when only one repo sells, and the global config when every project you touch sells through the same account. Create or edit the file so it contains:

{ "mcpServers": { "pocketsflow": { "url": "https://api.pocketsflow.com/mcp", "headers": { "Authorization": "Bearer pk_live_..." } } } }

For practice mode, use your pk_test_ key instead. Save the file and restart Cursor or reload the MCP servers from settings, then verify with a harmless read-only prompt first in agent mode: “list my Pocketsflow products.” If Cursor answers with your catalog, or an empty list on a new account, the connection works.

Project versus global config

A project .cursor/mcp.json travels with the repo, which is convenient but means you must keep the real key out of git. Prefer environment-variable substitution or Cursor's global config for keys, and commit only a template with a placeholder. Global config keeps one key for all projects and never risks a commit. Either way, confirm Cursor shows “pocketsflow” as connected and green before you try a write.

Same server, other clients

The same hosted server powers every MCP client. Claude Code adds it with claude mcp add --transport http, Windsurf and VS Code use mcp.json, and headless agents can use the stdio bridge with npx -y @pocketsflow/mcp plus POCKETSFLOW_API_KEY. There is also a one-command skill install via npx skills add Pocketsflow/pocketsflow-imperium@pocketsflow. Learn the URL and key pattern once and you can reuse it everywhere.

Step 3: Run your first sale from Cursor

Here is the canonical first transcript. Paste this into Cursor agent chat once connected: “Create a $49 one-time product called Pro license with a 20% launch discount, and give me the checkout link.” Behind the scenes Cursor chains three tools: create_product builds the $49 listing, create_discount adds the 20%-off launch code, and create_checkout_session returns a shareable payment link.

Before you share that link, know your numbers. Pocketsflow has no monthly selling fee; each sale carries an estimated itemized transaction cost of 4.7% + $0.30. For the $49 Pro license that is $49 × 0.047 + $0.30 ≈ $2.60, so you keep about $46.40. A buyer using the 20% launch code pays $39.20, the estimated cost is $39.20 × 0.047 + $0.30 ≈ $2.14, and you keep about $37.06. All figures are illustrative estimates—the exact amount varies by payment method, buyer region, and currency, and is itemized on every order:

Price with this math in mind from day one. Our guide to pricing digital products shows how to fold fees into prices customers still say yes to, and Pocketsflow itemizes the platform, payment infrastructure, tax handling when required, and dispute prevention on every order.

The 53 tools Cursor gets

The connection exposes 53 tools across 13 groups. You never call them directly—you describe outcomes and Cursor picks the calls. Here is the map so you know what to ask for: products (6), checkout (1), orders plus customers (4), subscriptions (3), refunds (3), discounts (5), upsells (5), reviews (1), webhooks (6), newsletters (10), link-in-bio (2), partners (6), and account (1).

Practical translation: products, discounts, upsells, and checkout cover launches; orders, refunds, and subscriptions cover operations; newsletters, link-in-bio, partners, and webhooks cover growth and automation. When that checkout link is ready, our guide to the best checkout for digital products explains what makes the page it points to convert.

Merchant-of-record cover while you ship

As your Merchant of Record, Pocketsflow assumes the legal and financial responsibility for each sale, including payment processing, tax calculation and remittance where required, fraud screening, and disputes. That is why an editor workflow is safe to scale: you prompt from Cursor while Pocketsflow handles global tax compliance and chargebacks behind the checkout link.

Five copy-paste prompts for Cursor sellers

Once the first product works, these cover a full selling week:

1. “Using test mode, draft a 25%-off weekend discount for my bestseller and show me the checkout link before creating anything.”
2. “Add a $19 order-bump upsell to my Pro license checkout and estimate my earnings per 100 buyers at a 15% take rate.”
3. “Summarize yesterday's orders: total revenue, refunds, and anything unusual I should look at.”
4. “Draft a newsletter to past buyers announcing the Pro license launch discount, but do not send it until I approve the copy.”
5. “Set up a partner program for the Pro license at 30% commission and draft the invite message for affiliates.”

Read every draft before it goes live, especially anything that charges money, refunds money, or emails customers. Cursor proposes; you approve.

Troubleshooting and safety rules

Three fixes cover most Cursor connection problems:

• Server not listed: confirm the file is named exactly .cursor/mcp.json in the right folder, that the JSON parses, and that the URL is https://api.pocketsflow.com/mcp with no trailing page path. Reload MCP servers after every edit.
• Unauthorized or empty catalog: you mixed up pk_test_ and pk_live_, or pasted the key with extra spaces or quotes. Re-check the Authorization: Bearer header value and test with “list my products” in each mode separately.
• Tools load but writes fail: update Cursor, start a new agent session, and ask Cursor to show the exact tool arguments for the failing call. The missing required field is usually obvious once visible.

And three rules keep agent commerce safe: build every new workflow in test mode first, require your explicit approval before refunds, mass emails, or price changes go out, and treat anything the agent quotes from customer data as untrusted input worth verifying in the dashboard. Scoped keys, narrow permissions, and a human in the loop are the whole security model.

You now know the exact .cursor/mcp.json shape, the test-versus-live key discipline, all 53 tools, and the fee math on a first $49 sale. The connector takes minutes; the catalog is the real work, and you can build that conversationally too. Start free on Pocketsflow and let your editor handle the busywork while you make the product.