Apify MCP Server Cursor IDE Setup (2026): Plugin, Hosted OAuth, API Token and Local stdio

How do you set up the Apify MCP server in Cursor? The shortest route is to run /add-plugin apify in Cursor's agent chat, then open Cursor Settings > Tools & MCPs and click Connect on the Apify server to finish the browser sign-in. If you prefer a plain config file, add one entry to ~/.cursor/mcp.json with "url": "https://mcp.apify.com" and Cursor starts the same OAuth sign-in on first use. For headless machines, send your Apify API token as an Authorization: Bearer header, or run npx -y @apify/actors-mcp-server locally with APIFY_TOKEN in the environment.

Everything below was checked on November 3, 2026 against Apify's MCP server documentation at docs.apify.com/platform/integrations/mcp, its Cursor integration page and its agent plugin page. Apify changes its tool list and install flow often, so where a detail is likely to move, this guide points to the page to recheck instead of freezing it.

What Apify Adds That a Fetch Server Doesn't

Apify is a platform of ready-made scrapers and automation programs called Actors, published in Apify Store. The MCP server lets an AI client search that store, read an Actor's input and output schema, run an Actor, and then read the results from Apify's storage. It also exposes Apify's documentation search so a coding assistant can look up the platform without leaving the editor.

That is a different job from the web servers already covered on this site. The Fetch MCP server pulls one URL into markdown from your machine. Playwright drives a browser you control step by step. Firecrawl scrapes, crawls and extracts on its own hosted infrastructure, and Exa focuses on search. Apify's angle is the catalog: if a maintained Actor already exists for a site type such as maps listings, social profiles or search results, your agent can find and run it rather than you writing a scraper.

Two limits are worth knowing before you start. Apify says the server intentionally excludes full-permission Actors from search and execution for security reasons, because approving a full-permission Actor is a decision you make personally, not one an LLM can make for you. And every Actor run consumes usage from your Apify plan, on top of whatever you spend on Cursor. This guide does not quote prices because they vary by Actor and change; Apify's fetch-actor-details tool returns an Actor's pricing before you run it.

Pick a Connection Method First

A quick rule: use the plugin if you want Apify's Agent Skills too, use hosted OAuth if you just want the server, and use a token only when no human can click through a browser sign-in.

Where the Config Lives in Cursor

Cursor reads MCP servers from two files. ~/.cursor/mcp.json in your home directory makes a server available in every project. .cursor/mcp.json in a project root scopes it to that repository, which is how teams share a setup through version control. Installed servers can also be managed from Cursor's settings, where you can toggle a server off without deleting it. Never commit a project-level file that contains a literal API token; the OAuth and environment-variable patterns below avoid that. Our general Cursor MCP setup guide covers the basics of both files.

Option 1: The Apify Plugin (Fastest in Cursor)

Apify maintains a Cursor plugin that bundles three things: the Apify MCP server at https://mcp.apify.com, an apify routing agent that picks the right tool or skill from a plain-language request, and five Agent Skills.

1. In Cursor's agent chat, run /add-plugin apify. You can also open Cursor Settings > Plugins, search for Apify, click Get, and choose This project or All projects as the install scope.
2. Open Cursor Settings > Tools & MCPs, scroll to the bottom, and find the Apify MCP server.
3. Click Connect. Cursor opens a browser tab for the Apify OAuth flow. Review the permissions and click Allow access.
4. Back in Cursor, the server should show as connected.

Apify says read-only tools such as searching Apify Store and fetching Actor details work without signing in, but you must authenticate to run Actors and access your account data. The connection persists across sessions, and you can revoke it in Apify Console > Settings > Integrations.

The five bundled skills are apify-ultimate-scraper (multi-step scraping and lead-generation workflows with existing Actors), apify-actor-development (building, testing and deploying your own Actor), apify-actorization (turning an existing project into an Actor), apify-generate-output-schema and apify-sdk-integration (calling Actors from your application through the apify-client package). Apify notes that the Actor development, actorization and scraping skills call the Apify CLI, so install it with npm install -g apify-cli and run apify login before using them. The plugin replaces the MCP configuration and the skills CLI, not the Apify CLI.

If Cursor picks the wrong skill, Apify's troubleshooting advice is to start your request with @apify so the routing agent handles it.

Option 2: Hosted Server With Browser Sign-In (OAuth)

If you want only the server, with no skills or routing agent, add this to ~/.cursor/mcp.json or the project file:

{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com"
    }
  }
}

Save, then reload Cursor or toggle the server off and on. Cursor supports OAuth for remote MCP servers, so the first connection opens a browser where you sign in to Apify and approve access. Apify describes this as the recommended remote connection because it authorizes the server without putting your API token in the client configuration.

Rolling Apify out across a team? Deciding which Actors an agent may run, setting spend caps and keeping tokens out of repositories are the parts that take time. Talk to us if you want help wiring Apify or other MCP servers into your stack.

Option 3: Hosted Server With an API Token

On a remote machine, a devcontainer or an SSH session there may be no browser for OAuth. Apify's Cursor troubleshooting says to authenticate with an API token in that case. Copy your token from Apify Console > Settings > Integrations (the MCP page describes the same page as API & Integrations) and keep the hosted URL, passing the token as a bearer header:

{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com",
      "headers": {
        "Authorization": "Bearer ${env:APIFY_TOKEN}"
      }
    }
  }
}

The ${env:APIFY_TOKEN} syntax is Cursor's config interpolation, which resolves variables inside url and headers so the token lives in your shell environment rather than a JSON file that might be committed. Set the variable before launching Cursor:

export APIFY_TOKEN=your-token-here

On macOS, apps launched from the Dock do not always see variables set in .zshrc. If authentication fails, start Cursor from a terminal where the variable is set. Treat the token like a password: it can start billable runs on your account, so never paste it into a chat or a URL.

Option 4: Run the Server Locally With npx

Apify supports a local stdio server for clients that don't handle remote MCP URLs and for development and testing:

{
  "mcpServers": {
    "actors-mcp-server": {
      "command": "npx",
      "args": ["-y", "@apify/actors-mcp-server@latest"],
      "env": {
        "APIFY_TOKEN": "${env:APIFY_TOKEN}"
      }
    }
  }
}

Apify documents the package without a tag and recommends appending @latest so you get current features and fixes; the config above does that. If you would rather pin a specific version for stability, replace latest with a version number you have reviewed, a good habit for any MCP server that runs code on your machine. The local server requires Node.js 18 or higher, so check node -v first. One documented difference: the hosted server supports output schema inference, which adds field-level type information to Actor tools so the agent knows the result structure before it runs anything. The local stdio server does not.

The Apify CLI can also write a client configuration for you: apify mcp install cursor, per Apify's MCP page.

Choosing Which Tools Cursor Sees

By default the server loads the actors and docs tool categories, the apify/rag-web-browser and apify/web-fetch Actors, and report-problem. You change that by adding a tools query parameter to the URL, for example:

{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=actors,docs,apify/rag-web-browser"
    }
  }
}

For a minimal setup where you only need specific Actors, list them directly, such as https://mcp.apify.com?tools=apify/google-search-scraper. Apify recommends specifying tools explicitly for production rather than relying on defaults, so behavior stays consistent across updates. Fewer tools also means a shorter tool list for the model to reason over. Apify's visual configurator at https://mcp.apify.com/ lets you pick tools and copy the generated config.

The default and optional tools fall into categories:

Note one behavior that surprises people: whenever call-actor or a specific Actor tool is loaded, the server also adds get-actor-run, get-dataset-items, get-key-value-store-record and abort-actor-run, even if you didn't select them. A default configuration exposes them too. The task and schedule tools can create saved configurations and cron runs on your account, so leave them off unless you want an agent making those changes.

How Running an Actor Actually Works

The agent flow has three steps, and understanding them prevents most confusion.

1. Find and inspect. search-actors finds candidates in Apify Store. fetch-actor-details returns the Actor's input and output schema, its README and its pricing. Reading this first lets the agent fill the input correctly and lets you see how the Actor is priced before anything runs.
2. Run. call-actor starts the Actor and waits up to waitSecs, which accepts 0 to 45 and defaults to 30. Run limits such as memory, timeout, maxItems and maxTotalChargeUsd go in callOptions, not in the Actor input. Setting maxItems and maxTotalChargeUsd is the practical way to cap a test run.
3. Read the results. call-actor returns the run's status and storage IDs, not its output. Use get-dataset-items with the datasetId from the run, which supports limit, offset and field filtering. If the Actor is still running, get-actor-run reports its status and get-actor-run-log shows its log.

Apify's Cursor page warns that long-running Actors may exceed the time a single tool call waits for completion. Reduce the scope or split the work across prompts rather than expecting one call to block for minutes.

Confirm It's Working

Ask Cursor something that exercises discovery without running anything. Apify's own first prompt is a good one: "Use Apify to find a good Actor for scraping Google Maps places. Show me the best option, its input requirements, pricing model, and what kind of dataset output it returns. Do not run the Actor yet." The agent should call search-actors and fetch-actor-details and summarize the result. If you see those tools in the call log, the connection works and you haven't spent anything.

When you do want a run, start small: "Run it for five places in Seattle with maxItems set to 5, then read the dataset items." Compare what the agent reports against the run in Apify Console.

Practical Prompts for Coding Work

Troubleshooting

Security and Cost Notes

Scraped pages become model input, so treat what an Actor returns as untrusted text: a page can contain instructions aimed at your agent. Keep write-capable tools like the task and schedule tools off unless needed, review the Actor an agent chooses before it runs, and keep run limits low while testing. Apify's server collects anonymous telemetry about tool calls and MCP client attributes, and says it does not collect conversations, tool arguments, tokens or personal data; you can opt out with ?telemetry-enabled=false on the hosted URL, or with --telemetry-enabled=false or TELEMETRY_ENABLED=false locally. For more on handling credentials and agent permissions, see our guides to authenticating MCP servers and MCP security best practices.

Frequently Asked Questions

What is the Apify MCP server URL for Cursor?

The hosted server is https://mcp.apify.com. Add it as a url entry under mcpServers in ~/.cursor/mcp.json and Cursor opens a browser sign-in on first connection. You can also install the Apify plugin from Cursor, which preconfigures the same server.

Do I need an Apify account to use the MCP server?

Not for discovery. Per Apify's docs, a connection URL whose tools parameter lists only search-actors, fetch-actor-details, search-apify-docs and fetch-apify-docs works without an API token. Running Actors and reading storage or run data always requires authentication.

Should I use the plugin or edit mcp.json myself?

Use the plugin if you want the MCP server plus Apify's Agent Skills and routing agent installed in one step. Edit mcp.json directly if you want the server only, need to restrict tools with the tools parameter, or want a reviewable config file you can share with a team.

Why does call-actor return no data?

By design. Apify's docs say call-actor returns the run's status and storage IDs, not its output. Use get-dataset-items with the datasetId from the run to read results, with limit, offset and field filtering.

How do I keep an Actor run from spending too much?

Pass run limits such as memory, timeout, maxItems and maxTotalChargeUsd in call-actor's callOptions, not in the Actor input, and check each Actor's pricing with fetch-actor-details before running it. Actor runs consume platform usage from your Apify plan.

What is the Apify MCP server's rate limit?

Apify documents up to 30 requests per second per user across all operations. Exceeding it returns a 429 response, so build retry logic into anything automated.