One Actor, four front doors

Build the logic once with the CLI. Push it. From then on the same Actor is reachable as a terminal command, as an MCP tool inside Claude Code, Cursor, and Codex, and as a plain HTTPS endpoint. You never rebuild it per client, you just point each client at it.

                         ONE ACTOR · FOUR FRONT DOORS

     you build once                                access anywhere
   ┌───────────────┐        ┌──────────────┐        ┌────────────────────────┐
   │  apify create │───────▶│  apify push  │───────▶│  terminal   apify call │
   │  write logic  │        │  build in    │        │  Claude Code  MCP tool  │
   │  apify run    │        │  the cloud   │        │  Cursor       MCP tool  │
   └───────────────┘        └──────────────┘        │  Codex        MCP tool  │
                                                     │  HTTPS        REST API  │
                                                     └────────────────────────┘

Explore the guide

From empty folder to deployed, in five commands

The CLI runs Actors locally for fast iteration, then pushes the exact same code to the cloud where it builds into a Docker image. You do not need Docker knowledge to start, the templates handle it.

1 · Install & log in

# npm (Node 18+): or: curl -fsSL https://apify.com/install-cli.sh | bash
npm install -g apify-cli

# authorize the CLI with your Apify API token (stored in ~/.apify)
apify login

2 · Scaffold from a template

# interactive: pick a JS/TS or Python template (each ships AGENTS.md for AI coding)
apify create my-actor
cd my-actor

3 · Run locally, then push

# run on your machine against local input: iterate fast
apify run

# upload + build in the Apify cloud (Actor must be built before cloud runs)
apify push

That is the whole loop: create → edit logic → run → push. Input is defined by .actor/INPUT_SCHEMA.json, output lands in a Dataset. See the Wiki for what each of those terms means.

Terminal, Claude Code, Cursor, Codex

This is the part most people miss. Your Actor is not trapped in the Apify Console. One CLI command wires it into your AI editors as an MCP tool, and it is always reachable from the terminal and over HTTPS.

Door 1 · Terminal

# call any Actor by name, pass JSON input, read the dataset back
apify call my-actor --input '{ "startUrls": ["https://example.com"] }'

# or hit the REST API from anything that speaks HTTP
curl "https://api.apify.com/v2/acts/USERNAME~my-actor/runs/last/dataset/items?token=APIFY_TOKEN"

Doors 2–4 · Claude Code, Cursor, Codex (one command each)

The CLI installs the Apify MCP server into a client's own config. Supported clients: claude-code, cursor, codex, vscode, kiro, antigravity. It reuses the token from apify login.

apify mcp install claude-code
apify mcp install cursor
apify mcp install codex

# scope it down to just the tools/Actors you want exposed
apify mcp install cursor --tools search-actors,apify/rag-web-browser

Prefer wiring it by hand, or using Claude Desktop's connector directory? Point the client at the hosted endpoint and approve the OAuth prompt in your browser, no token in a file:

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

Once connected, the assistant can search-actors, read an Actor's schema, and call-actor on demand, then pull results with get-dataset-items. It discovers your Actor without you pre-configuring it.

Publish once, the team forks it

A built Actor is already private-usable. Publishing it to the Apify Store makes it discoverable and forkable, so a teammate runs the same Actor instead of rebuilding your logic. This is how a personal primitive becomes team leverage.

• Add the essentials: a clear .actor/INPUT_SCHEMA.json and a real README.md so others can run it without asking you.
• Complete publication info: Console → your Actor → Publication: icon, name, short description, categories.
• Publish to Store: click Publish when eligible; working runs and honest docs are expected.
• Monetize (optional): pay-per-result, pay-per-event, or rental from the Monetization tab.

Stack & conventions

You write standard code; the platform handles container build, proxies, storage, scheduling, and an HTTPS API. Node 18+ is required for the CLI and the local MCP server.

my-actor/
  .actor/
    actor.json          # links local project to the platform Actor
    INPUT_SCHEMA.json   # defines the input form + validation
  src/                  # your entrypoint: Actor.init() ... Actor.exit()
  Dockerfile            # how the Actor builds in the cloud
  AGENTS.md             # context for AI coding assistants

Run, schedule, read results

After apify push, start it from the Console, the terminal, an editor, or on a schedule. Results always land in a Dataset you can read over the API.

# run in the cloud and wait for results
apify call my-actor --input '{ "maxItems": 50 }'

# read the latest run's dataset
curl "https://api.apify.com/v2/acts/USERNAME~my-actor/runs/last/dataset/items?token=APIFY_TOKEN"

Schedules, webhooks (Slack, Sheets, any HTTP endpoint), and storage all come with the platform, no infra to run. Free tier includes ~$5/month of compute to start.

Bonus freebie

Scan for the workshop drop

The full build-your-own-Actor session, free primitives, and the Plugin Watcher fork are waiting behind this code. Point your phone, claim your seat.

workshops.organizedai.vip/offer

workshops.organizedai.vip/offer