Apify MCP

What you can do

Connect this agent connector to let your agent:

• Get get — Get detailed information about a specific Actor run by runId
• Fetch fetch — Get detailed information about an Actor by its ID or full name (format: ‘username/name’, e.g
• Search search — Search the Apify Store to FIND and DISCOVER what scraping tools/Actors exist for specific platforms or use cases
• Actor call — Call any Actor from the Apify Store
• Browser rag web — Web browser for AI agents and RAG pipelines

Authentication

This connector uses Bearer Token authentication. Scalekit securely stores the token and injects it into API requests on behalf of your users. Your agent code never handles tokens directly — you only pass a connectionName and a user identifier.

Set up the connector

Register your Apify API token with Scalekit so it can authenticate and proxy Actor requests on behalf of your users. Unlike OAuth connectors, Apify MCP uses API token authentication — there is no redirect URI or OAuth flow.

1. Get an Apify API token

   • Go to console.apify.com and sign in or create a free account.

   • In the left sidebar, click your avatar → Settings → API & Integrations → API tokens.

   • Click + Create new token. Give it a name (e.g., Agent Auth) and click Create token.

   • Copy the token immediately — it will not be shown again.

2. Create a connection in Scalekit

   • In Scalekit dashboard, go to Agent Auth → Connections. Find Apify MCP and click Create.

   • Note the Connection name — you will use this as connection_name in your code (e.g., apifymcp).

3. Add a connected account

   Connected accounts link a specific user identifier in your system to an Apify API token. Add them via the dashboard for testing, or via the Scalekit API in production.

   Via dashboard (for testing)

   • Open the connection you created and click the Connected Accounts tab → Add account.

   • Fill in:

     • Your User’s ID — a unique identifier for this user in your system (e.g., user_123)
     • Apify Token — the token you copied in step 1

   • Click Save.

   Via API (for production)

   Node.js

   await scalekit.actions.upsertConnectedAccount({
     connectionName: 'apifymcp',
     identifier: 'user_123',       // your user's unique ID
     credentials: { token: 'apify_api_...' },
   });

   Python

   scalekit_client.actions.upsert_connected_account(
       connection_name="apifymcp",
       identifier="user_123",
       credentials={"token": "apify_api_..."}
   )

Code examples

Connect a user’s Apify account and run web scraping and data extraction Actors through Scalekit. Scalekit handles token storage and tool execution automatically.

Apify MCP is primarily used through Scalekit tools. Use scalekit_client.actions.execute_tool() to discover Actors, fetch their input schemas, run them, and retrieve output — without handling Apify credentials in your application code.

Tool calling

Use this connector when you want an agent to run web scraping or data extraction tasks using Apify Actors.

• Use apifymcp_search_actors to discover Actors for a specific platform or use case before deciding which to run.
• Use apifymcp_fetch_actor_details to retrieve an Actor’s input schema before calling it — always pass output: { inputSchema: true } to keep the response concise.
• Use apifymcp_call_actor to run an Actor synchronously, or with async: true for long-running tasks.
• Use apifymcp_get_actor_run to poll the status of an async run, and apifymcp_get_actor_output to retrieve results once complete.
• Use apifymcp_rag_web_browser when you need real-time web content for LLM grounding — it returns clean Markdown from the top search result pages.

Python

examples/apifymcp_fetch_actor_details.py

import os
from scalekit.client import ScalekitClient

scalekit_client = ScalekitClient(
    client_id=os.environ["SCALEKIT_CLIENT_ID"],
    client_secret=os.environ["SCALEKIT_CLIENT_SECRET"],
    env_url=os.environ["SCALEKIT_ENV_URL"],
)

connected_account = scalekit_client.actions.get_or_create_connected_account(
    connection_name="apifymcp",
    identifier="user_123",
)

tool_response = scalekit_client.actions.execute_tool(
    tool_name="apifymcp_fetch_actor_details",
    connected_account_id=connected_account.connected_account.id,
    tool_input={
        "actor": "apify/web-scraper",
    },
)
print("Actor details:", tool_response)

Node.js

examples/apifymcp_fetch_actor_details.ts

import { ScalekitClient } from '@scalekit-sdk/node';
import 'dotenv/config';

const scalekit = new ScalekitClient(
  process.env.SCALEKIT_ENV_URL!,
  process.env.SCALEKIT_CLIENT_ID!,
  process.env.SCALEKIT_CLIENT_SECRET!
);
const actions = scalekit.actions;

const connectedAccount = await actions.getOrCreateConnectedAccount({
  connectionName: 'apifymcp',
  identifier: 'user_123',
});

const toolResponse = await actions.executeTool({
  toolName: 'apifymcp_fetch_actor_details',
  connectedAccountId: connectedAccount?.id,
  toolInput: {
    actor: 'apify/web-scraper',
  },
});
console.log('Actor details:', toolResponse.data);

Tool list

apifymcp_call_actor Call any Actor from the Apify Store. By default waits for completion and returns results with a dataset preview. Use async mode to start a run in the background and get a runId immediately. Workflow: 1. Use apifymcp_fetch_actor_details with output: {"inputSchema": true} to get the Actor's exact input schema 2. Call this tool with the actor name and input matching that schema exactly 3. Use apifymcp_get_actor_output with the returned datasetId to fetch full results if needed For MCP server Actors, use format 'actorName:toolName' (e.g. 'apify/actors-mcp-server:fetch-apify-docs'). Use dedicated Actor tools (e.g. apifymcp_rag_web_browser) when available instead of this tool. When NOT to use: - You don't know the Actor's input schema — use apifymcp_fetch_actor_details first 5 params ▾

Call any Actor from the Apify Store. By default waits for completion and returns results with a dataset preview. Use async mode to start a run in the background and get a runId immediately. Workflow: 1. Use apifymcp_fetch_actor_details with output: {"inputSchema": true} to get the Actor's exact input schema 2. Call this tool with the actor name and input matching that schema exactly 3. Use apifymcp_get_actor_output with the returned datasetId to fetch full results if needed For MCP server Actors, use format 'actorName:toolName' (e.g. 'apify/actors-mcp-server:fetch-apify-docs'). Use dedicated Actor tools (e.g. apifymcp_rag_web_browser) when available instead of this tool. When NOT to use: - You don't know the Actor's input schema — use apifymcp_fetch_actor_details first

Name Type Required Description

actor string required Actor ID or full name in 'username/name' format (e.g. 'apify/rag-web-browser'). For MCP server Actors use 'actorName:toolName' format.

input object required Input JSON to pass to the Actor. Must match the Actor's input schema exactly — use apifymcp_fetch_actor_details with output: {"inputSchema": true} first to get the required fields and types.

async boolean optional If true, starts the run and returns immediately with a runId. Use only when the user explicitly asks to run in the background or does not need immediate results.

callOptions object optional Optional run configuration options

previewOutput boolean optional When true (default), includes preview items in the response. Set to false when you plan to fetch full results separately via apifymcp_get_actor_output — avoids duplicate data and saves tokens.

apifymcp_fetch_actor_details Get detailed information about an Actor by its ID or full name (format: 'username/name', e.g. 'apify/rag-web-browser'). WARNING: Omitting the 'output' parameter returns ALL fields including the full README, which can be extremely token-heavy. Always pass 'output' with only the fields you need. To get the input schema before calling an Actor, use: {"inputSchema": true}. When to use: - You need an Actor's input schema before calling it — use output: {"inputSchema": true} - User wants details about a specific Actor (pricing, description, README) - You need to list MCP tools provided by an MCP server Actor — use output: {"mcpTools": true} When NOT to use: - You already have the input schema and are ready to run — use apifymcp_call_actor directly 2 params ▾

Get detailed information about an Actor by its ID or full name (format: 'username/name', e.g. 'apify/rag-web-browser'). WARNING: Omitting the 'output' parameter returns ALL fields including the full README, which can be extremely token-heavy. Always pass 'output' with only the fields you need. To get the input schema before calling an Actor, use: {"inputSchema": true}. When to use: - You need an Actor's input schema before calling it — use output: {"inputSchema": true} - User wants details about a specific Actor (pricing, description, README) - You need to list MCP tools provided by an MCP server Actor — use output: {"mcpTools": true} When NOT to use: - You already have the input schema and are ready to run — use apifymcp_call_actor directly

Name Type Required Description

actor string required Actor ID or full name in 'username/name' format (e.g. 'apify/rag-web-browser')

output object optional JSON object with boolean flags to control which fields are returned. Always specify this to avoid a large token-heavy response. Set only the fields you need to true. Available fields: description, inputSchema, mcpTools, metadata, outputSchema, pricing, rating, readme, stats. All default to true if omitted (very large response) except mcpTools. Example: {"inputSchema": true}

apifymcp_fetch_apify_docs Fetch the full content of an Apify or Crawlee documentation page by its URL. Use this after finding a relevant page with apifymcp_search_apify_docs. When to use: - You have a documentation URL and need the complete page content - User asks for detailed documentation on a specific Apify or Crawlee page When NOT to use: - You don't have a URL yet — use apifymcp_search_apify_docs first 1 param ▾

Fetch the full content of an Apify or Crawlee documentation page by its URL. Use this after finding a relevant page with apifymcp_search_apify_docs. When to use: - You have a documentation URL and need the complete page content - User asks for detailed documentation on a specific Apify or Crawlee page When NOT to use: - You don't have a URL yet — use apifymcp_search_apify_docs first

Name Type Required Description

url string required Full URL of the Apify or Crawlee documentation page (e.g. 'https://docs.apify.com/platform/actors')

apifymcp_get_actor_output Retrieve output dataset items from a specific Actor run using its datasetId. Supports field selection (including dot notation) and pagination. When to use: - You have a datasetId from an Actor run and need the full results - The preview from apifymcp_call_actor didn't include all needed fields - You need to paginate through large datasets When NOT to use: - You don't have a datasetId yet — run an Actor with apifymcp_call_actor first 4 params ▾

Retrieve output dataset items from a specific Actor run using its datasetId. Supports field selection (including dot notation) and pagination. When to use: - You have a datasetId from an Actor run and need the full results - The preview from apifymcp_call_actor didn't include all needed fields - You need to paginate through large datasets When NOT to use: - You don't have a datasetId yet — run an Actor with apifymcp_call_actor first

Name Type Required Description

datasetId string required Actor output dataset ID to retrieve from

fields string optional Comma-separated list of fields to include. Supports dot notation for nested fields (e.g. 'crawl.httpStatusCode,metadata.url'). Note: dot-notation fields are returned as flat keys in the output — e.g. requesting 'crawl.httpStatusCode' returns {"crawl.httpStatusCode": 200}, not a nested object.

limit number optional Maximum number of items to return (default: 100)

offset number optional Number of items to skip for pagination (default: 0)

apifymcp_get_actor_run Get detailed information about a specific Actor run by runId. Returns run metadata (status, timestamps), performance stats, and resource IDs (datasetId, keyValueStoreId, requestQueueId). When to use: - You have a runId from apifymcp_call_actor (async mode) and want to check its status - User asks about details of a specific run started outside the current conversation When NOT to use: - The run was just started via apifymcp_call_actor in sync mode — results are already in the response - You want the output data — use apifymcp_get_actor_output with the datasetId 1 param ▾

Get detailed information about a specific Actor run by runId. Returns run metadata (status, timestamps), performance stats, and resource IDs (datasetId, keyValueStoreId, requestQueueId). When to use: - You have a runId from apifymcp_call_actor (async mode) and want to check its status - User asks about details of a specific run started outside the current conversation When NOT to use: - The run was just started via apifymcp_call_actor in sync mode — results are already in the response - You want the output data — use apifymcp_get_actor_output with the datasetId

Name Type Required Description

runId string required The ID of the Actor run

apifymcp_rag_web_browser Web browser for AI agents and RAG pipelines. Queries Google Search, scrapes the top N pages, and returns content as Markdown. Can also scrape a specific URL directly. When to use: - User wants current/immediate data (e.g. 'Get flight prices for tomorrow', 'What's the weather today?') - User needs to fetch specific content now (e.g. 'Fetch news from CNN', 'Get product info from Amazon') - User has time indicators like 'today', 'current', 'latest', 'recent', 'now' When NOT to use: - User needs repeated/scheduled scraping of a specific platform — search for a dedicated Actor using apifymcp_search_actors instead 3 params ▾

Web browser for AI agents and RAG pipelines. Queries Google Search, scrapes the top N pages, and returns content as Markdown. Can also scrape a specific URL directly. When to use: - User wants current/immediate data (e.g. 'Get flight prices for tomorrow', 'What's the weather today?') - User needs to fetch specific content now (e.g. 'Fetch news from CNN', 'Get product info from Amazon') - User has time indicators like 'today', 'current', 'latest', 'recent', 'now' When NOT to use: - User needs repeated/scheduled scraping of a specific platform — search for a dedicated Actor using apifymcp_search_actors instead

Name Type Required Description

query string required Google Search keywords or a specific URL to scrape. Supports advanced search operators.

maxResults integer optional Maximum number of top Google Search results to scrape and return. Ignored when query is a direct URL. Higher values increase response time and compute cost significantly — keep low (1-3) for latency-sensitive use cases. Default: 3.

outputFormats array optional Output formats for the scraped page content. Options: 'markdown', 'text', 'html' (default: ['markdown'])

apifymcp_search_actors Search the Apify Store to FIND and DISCOVER what scraping tools/Actors exist for specific platforms or use cases. This tool provides INFORMATION about available Actors — it does NOT retrieve actual data or run any scraping tasks. When to use: - Find what scraping tools exist for a platform (e.g. 'What tools can scrape Instagram?') - Discover available Actors for a use case (e.g. 'Find an Actor for Amazon products') - Browse existing solutions before calling an Actor When NOT to use: - User wants immediate data retrieval — use apifymcp_rag_web_browser instead - You already know the Actor ID — use apifymcp_fetch_actor_details or apifymcp_call_actor directly Always do at least two searches: first with broad keywords, then with more specific terms if needed. 3 params ▾

Search the Apify Store to FIND and DISCOVER what scraping tools/Actors exist for specific platforms or use cases. This tool provides INFORMATION about available Actors — it does NOT retrieve actual data or run any scraping tasks. When to use: - Find what scraping tools exist for a platform (e.g. 'What tools can scrape Instagram?') - Discover available Actors for a use case (e.g. 'Find an Actor for Amazon products') - Browse existing solutions before calling an Actor When NOT to use: - User wants immediate data retrieval — use apifymcp_rag_web_browser instead - You already know the Actor ID — use apifymcp_fetch_actor_details or apifymcp_call_actor directly Always do at least two searches: first with broad keywords, then with more specific terms if needed.

Name Type Required Description

keywords string optional Space-separated keywords to search Actors in the Apify Store. Use 1-3 simple terms (e.g. 'Instagram posts', 'Amazon products'). Avoid generic terms like 'scraper' or 'crawler'. Omitting keywords or passing an empty string returns popular/general Actors — always provide keywords for relevant results.

limit integer optional Maximum number of Actors to return (1-100, default: 5)

offset integer optional Number of results to skip for pagination (default: 0)

apifymcp_search_apify_docs Search Apify and Crawlee documentation using full-text search. Use keywords only, not full sentences. Select the documentation source explicitly via docSource. Sources: - 'apify': Platform docs, SDKs (JS, Python), CLI, REST API, Academy, Actor development - 'crawlee-js': Crawlee JavaScript web scraping library - 'crawlee-py': Crawlee Python web scraping library When to use: - User asks how to use Apify APIs, SDK, or platform features - You need to look up Apify or Crawlee documentation When NOT to use: - You already have a documentation URL — use apifymcp_fetch_apify_docs directly 4 params ▾

Search Apify and Crawlee documentation using full-text search. Use keywords only, not full sentences. Select the documentation source explicitly via docSource. Sources: - 'apify': Platform docs, SDKs (JS, Python), CLI, REST API, Academy, Actor development - 'crawlee-js': Crawlee JavaScript web scraping library - 'crawlee-py': Crawlee Python web scraping library When to use: - User asks how to use Apify APIs, SDK, or platform features - You need to look up Apify or Crawlee documentation When NOT to use: - You already have a documentation URL — use apifymcp_fetch_apify_docs directly

Name Type Required Description

query string required Algolia full-text search query using keywords only (e.g. 'standby actor', 'proxy configuration'). Do not use full sentences.

docSource string optional Documentation source to search. Options: 'apify' (default), 'crawlee-js', 'crawlee-py'

limit number optional Maximum number of results to return (1-20, default: 5)

offset number optional Offset for pagination (default: 0)