openactors

Call an Actor

call-actor

Run an Apify-compatible actor with your input, get a preview of collected items, and retrieve the full dataset via the returned dataset ID.

Instructions

Run an Actor and return its results. The shape of input depends on the Actor — read it from fetch-actor-details first. Returns a preview of the items plus a datasetId for retrieving the rest via get-dataset-items. A run that partially fails still returns what it collected; check get-actor-log for detail.

Tool call template

Replace each placeholder with a value matching the input schema. Only required parameters are included; add optional parameters as needed.

{
  "id": 1,
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "arguments": {
      "actor": "<actor>"
    },
    "name": "call-actor"
  }
}

Input Schema

Name	Required	Description
`actor`	Yes	Actor id, e.g. "jobs/ats-boards".
`input`	No	The Actor's input object.
`waitSecs`	No	How long to wait for the run before returning. If it is still going, you get the runId and can poll get-actor-run, then read results with get-dataset-items. The default sits under the 60-second request timeout most MCP clients use — set 0 to start a long crawl and return immediately.
`timeoutSecs`	No
`memoryMbytes`	No	Heap ceiling for the Actor process. Raise it for a large crawl; a run that exceeds it is killed rather than exhausting the machine.

Schema Changelog

Changes observed during successful MCP inspections.

First observedv0.1.0Sep 5, 2026

TDQS

A4.5/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations available, the description carries the behavioral disclosure burden. It does well by revealing partial-failure semantics, the fact that only a preview is returned, and that the datasetId is needed for full retrieval. It does not mention cost or that the run may keep executing after waitSecs, but the waitSecs schema covers the polling behavior.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is compact, with no filler. It front-loads the core operation, then adds the most important caveats and follow-up steps in clear, short sentences.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Despite having no output schema or annotations, the description covers the essential workflow: input dependency, return shape, retrieval path, and failure behavior. Combined with the detailed waitSecs schema, an agent has enough context to call the tool correctly.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The description adds real semantic value for the `input` parameter by warning that its shape depends on the Actor and pointing the agent to fetch-actor-details. The schema already describes most other parameters well, though `timeoutSecs` remains undocumented in both the description and the schema, which prevents a top score.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the operation: 'Run an Actor and return its results.' It also distinguishes the tool from siblings like run-actor-task and get-actor-run by describing the return contract (preview plus datasetId). The explicit link to fetch-actor-details reinforces what this tool is and is not.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description gives concrete workflow guidance: read fetch-actor-details first, retrieve the rest via get-dataset-items, and check get-actor-log for partial failures. It does not explicitly contrast call-actor with run-actor-task or state when scheduling would be a better fit, so it stops short of a 5.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.