Apify

by apify

441 968 downloads Not rated yet MIT

About

[Actors MCP Server](https://apify.com/apify/actors-mcp-server): Use 3,000+ pre-built cloud tools to extract data from websites, e-commerce, social media, search engines, maps, and more

Details

Repository
apify/apify-mcp-server
License
MIT

Explore

- Dynamically discover and use any Apify Actor as an MCP tool.
- Pre-configured with apify/rag-web-browser and helper tools.
- Supports OAuth for easy client integration.
- Agentic payments with x402 (USDC on Base) and Skyfire (PAY tokens).
- Streamable HTTP transport; compatible with Claude Desktop, Claude.ai, VS Code, Cursor, and others.
- Loads each Actor’s input schema to create corresponding MCP tools.

Setting up with Highlight

This MCP is not yet compatible with Highlight’s one-click setup. However, you can still use it with Highlight by following these steps:

  1. Download and install Highlight from highlightai.com/download
  2. Navigate to the plugins tab and select "Add Custom Plugin"
  3. Configure the plugin with the settings below
    Plugin Name Apify
    Command (node, npx, python, etc.) npx
    Arguments
    • Argument 1 @apify/actors-mcp-server
    Environment
    • APIFY_TOKEN your-apify-token

    Please refer to the README for specific instructions on how to obtain API keys or other required environment variables.

  4. Enable "Start Automatically" if you want the plugin to start when Highlight launches

From the repository

- A wallet with USDC on Base mainnet.

You can use the Apify MCP Server in two ways:

HTTPS Endpoint (mcp.apify.com): Connect from your MCP client via OAuth or by including the Authorization: Bearer <APIFY_TOKEN> header in your requests. This is the recommended method for most use cases. Because it supports OAuth, you can connect from clients like Claude.ai or Visual Studio Code using just the URL: https://mcp.apify.com.
- https://mcp.apify.com streamable transport

Standard Input/Output (stdio): Ideal for local integrations and command-line tools like the Claude for Desktop client.
- Set the MCP client server command to npx @apify/actors-mcp-server and the APIFY_TOKEN environment variable to your Apify API token.
- See npx @apify/actors-mcp-server --help for more options.

You can find detailed instructions for setting up the MCP server in the Apify documentation.

The tools configuration parameter is used to specify loaded tools – either categories or specific tools directly, and Apify Actors. For example, tools=storage,runs loads two categories; tools=call-actor loads just one tool.

When no query parameters are provided, the MCP server loads the following tools by default:

- actors
- docs
- apify/rag-web-browser

If the tools parameter is specified, only the listed tools or categories will be enabled – no default tools will be included.

report-problem is served by default (subject to the gating in the footnote above) but lives in the dev category, so an explicit tools=dev selects it too. To disable it, pass an explicit tools= list that omits it (e.g. tools=actors,docs).

> Easy configuration:
>
> Use the UI configurator to configure your server, then copy the configuration to your client.

Configuring the hosted server:

The hosted server can be configured using query parameters in the URL. For example, to load the default tools, use:

```

search-actors

Search for Actors in Apify Store.

fetch-actor-details

Retrieve detailed information about a specific Actor, including its input schema, README, pricing, and Actor output schema.

call-actor

Call an Actor and get its run results. Use fetch-actor-details first to get the Actor's input schema.

get-actor-run

Get detailed information about a specific Actor run.

get-dataset-items

Retrieve items from a dataset with support for filtering and pagination.

get-key-value-store-record

Get the value associated with a specific key in a key-value store.

abort-actor-run

Abort a running Actor run, optionally gracefully.

search-apify-docs

Search the Apify documentation for relevant pages.

fetch-apify-docs

Fetch the full content of an Apify documentation page by its URL.

apify--rag-web-browser

An Actor tool to browse the web.

report-problem

Report a problem with an Apify tool or Actor to the Apify team.

get-actor-run-list

Get a list of an Actor's runs, filterable by status.

get-actor-log

Retrieve the logs for a specific Actor run.

get-dataset

Get metadata about a specific dataset.

get-dataset-schema

Generate a JSON schema from dataset items.

get-key-value-store

Get metadata about a specific key-value store.

get-key-value-store-keys

List the keys within a specific key-value store.

get-dataset-list

List all available datasets for the user.

get-key-value-store-list

List all available key-value stores for the user.

create-actor-task

Create a saved Actor task (a named, reusable Actor configuration).

get-actor-task

Get a saved Actor task, its publication state and public display configuration.

update-actor-task

Update a task's input, run options, or public display configuration.

publish-actor-task

Publish a task on its public landing page.

unpublish-actor-task

Unpublish a task from its public landing page.

The MCP server provides a set of tools for interacting with Apify Actors.
Since Apify Store is large and growing rapidly, the MCP server provides a way to dynamically discover and use new Actors.

One of the most powerful features of using MCP with Apify is dynamic tool discovery.
It allows an AI agent to find new tools (Actors) as needed and incorporate them.
Here are some special MCP operations and how the Apify MCP Server supports them:

- Apify Actors: Search for Actors, view their details, and use them as tools for the AI.
- Apify documentation: Search the Apify documentation and fetch specific documents to provide context to the AI.
- Actor runs: Get lists of your Actor runs, inspect their details, and retrieve logs.
- Apify storage: Access data from your datasets and key-value stores.
- Actor tasks: Create, inspect, and update your saved Actor tasks, and publish or unpublish their public landing pages.

Here is an overview list of all the tools provided by the Apify MCP Server.

Legend for the Enabled by default column:
- ✅ — in the default tool set.
- ⚡ — auto-injected when call-actor, an Actor tool, or get-actor-run is present (which is true in the default configuration).
- ✅¹ — served by default, but only when telemetry is enabled and the client is not withheld: Anthropic surfaces (Claude.ai / Claude Desktop / Claude Code) or local-agent-mode-apify. To disable, pass an explicit tools= list that omits it.

| Tool name | Category | Description | Enabled by default |
| :--- | :--- | :--- | :---: |
| search-actors | actors | Search for Actors in Apify Store. | ✅ |
| fetch-actor-details | actors | Retrieve detailed information about a specific Actor, including its input schema, README (summary when available, full otherwise), pricing, and Actor output schema. | ✅ |
| call-actor | actors | Call an Actor and get its run results. Use fetch-actor-details first to get the Actor's input schema. | ✅ |
| get-actor-run | runs | Get detailed information about a specific Actor run. | ⚡ |
| get-dataset-items | storage | Retrieve items from a dataset with support for filtering and pagination. | ⚡ |
| get-key-value-store-record| storage | Get the value associated with a specific key in a key-value store. | ⚡ |
| abort-actor-run | runs | Abort a running Actor run, optionally gracefully. | ⚡ |
| search-apify-docs | docs | Search the Apify documentation for relevant pages. | ✅ |
| fetch-apify-docs | docs | Fetch the full content of an Apify documentation page by its URL. | ✅ |
| apify--rag-web-browser | Actor (see tool configuration) | An Actor tool to browse the web. | ✅ |
| report-problem | dev | Report a problem with an Apify tool or Actor to the Apify team. | ✅¹ |
| get-actor-run-list | runs | Get a list of an Actor's runs, filterable by status. | |
| get-actor-log | runs | Retrieve the logs for a specific Actor run. | |
| get-dataset | storage | Get metadata about a specific dataset. | |
| get-dataset-schema | storage | Generate a JSON schema from dataset items. | |
| get-key-value-store | storage | Get metadata about a specific key-value store. | |
| get-key-value-store-keys| storage | List the keys within a specific key-value store. | |
| get-dataset-list | storage | List all available datasets for the user. | |
| get-key-value-store-list| storage | List all available key-value stores for the user. | |
| create-actor-task | tasks | Create a saved Actor task (a named, reusable Actor configuration). | |
| get-actor-task | tasks | Get a saved Actor task, its publication state and public display configuration. | |
| update-actor-task | tasks | Update a task's input, run options, or public display configuration. | |
| publish-actor-task | tasks | Publish a task on its public landing page. | |
| unpublish-actor-task | tasks | Unpublish a task from its public landing page. | |

> Note:
>
> When call-actor, an Actor tool, or get-actor-run is present, the server auto-injects get-actor-run, get-dataset-items, get-key-value-store-record, and abort-actor-run.
>
> When you call an Actor — through call-actor or directly via an Actor tool (e.g., apify--rag-web-browser) — the response contains run metadata, storage IDs, and a summary + nextStep, but no dataset items. To fetch items, follow nextStep and call get-dataset-items (auto-injected), passing the datasetId returned from the call.

All tools include metadata annotations to help MCP clients and LLMs understand tool behavior:

- title: Short display name for the tool (e.g., "Search Actors", "Call Actor", "apify/rag-web-browser")
- readOnlyHint: true for tools that only read data without modifying state (e.g., get-dataset, fetch-actor-details)
- openWorldHint: true for tools that access external resources outside the Apify platform (e.g., call-actor executes external Actors). Tools that interact only with the Apify platform (like search-actors or fetch-apify-docs) do not have this hint.

The tools configuration parameter is used to specify loaded tools – either categories or specific tools directly, and Apify Actors. For example, tools=storage,runs loads two categories; tools=call-actor loads just one tool.

When no query parameters are provided, the MCP server loads the following tools by default:

- actors
- docs
- apify/rag-web-browser

If the tools parameter is specified, only the listed tools or categories will be enabled – no default tools will be included.

report-problem is served by default (subject to the gating in the footnote above) but lives in the dev category, so an explicit tools=dev selects it too. To disable it, pass an explicit tools= list that omits it (e.g. tools=actors,docs).

> Easy configuration:
>
> Use the UI configurator to configure your server, then copy the configuration to your client.

Configuring the hosted server:

The hosted server can be configured using query parameters in the URL. For example, to load the default tools, use:

```

Claude Desktop / Cursor

Paste into your MCP client config file to install this server.

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

Linux

{
    "env": {
        "APIFY_TOKEN": "your-apify-token"
    },
    "args": [
        "@apify/actors-mcp-server"
    ],
    "command": "npx"
}

Macos

{
    "env": {
        "APIFY_TOKEN": "your-apify-token"
    },
    "args": [
        "@apify/actors-mcp-server"
    ],
    "command": "npx"
}

Windows

{
    "env": {
        "APIFY_TOKEN": "your-apify-token"
    },
    "args": [
        "/c",
        "npx",
        "@apify/actors-mcp-server"
    ],
    "command": "cmd"
}

Actors

Any Apify Actor can be used as a tool.
By default, the server is pre-configured with one Actor, apify/rag-web-browser, and several helper tools.
The MCP server loads an Actor's input schema and creates a corresponding MCP tool.
This allows the AI agent to know exactly what arguments to pass to the Actor and what to expect in return.

For example, for the apify/rag-web-browser Actor, the input parameters are:

{
  "query": "restaurants in San Francisco",
  "maxResults": 3
}
You don't need to manually specify which Actor to call or its input parameters; the LLM handles this automatically. When a tool is called, the arguments are automatically passed to the Actor by the LLM. You can refer to the specific Actor's documentation for a list of available arguments.
No reviews yet — be the first

Sign in to leave a review

Use Google, GitHub, or an email account so ratings stay tied to real people.

Email sign in

No reviews posted yet.

Videos about Apify

Relevant YouTube tutorials, setups, and demos