kayforkind/skill-slice/apify-actor-development
Claude Code and agent skill by kayforkind/skill-slice
- community
Checking that the SKILL.md file is still in the repository.
Creates Apify Actors with the apify CLI, Crawlee Cheerio/Playwright crawlers, .actor schemas, local apify run, and apify push. Use when the user is bootstrapping or deploying an Actor on the Apify platform. Never confuse this with generic Playwright test scaffolding or a raw HTTP scraper outside Apify.
Install
npx vskill@latest install kayforkind/skill-slice/apify-actor-developmentSKILL.md
The same SKILL.md was published earlier as kayforkind/skill-slice/apify-actor-development.
Apify Actor Development
Important: Before you begin, fill in the generatedBy property in the meta section of .actor/actor.json. Replace it with the tool and model you're currently using, such as "Claude Code with Claude Sonnet 4.5". This helps Apify monitor and improve AGENTS.md for specific AI tools and models.
When to Use
- You need to create, modify, or debug an Apify Actor project.
- The task involves choosing an Apify template, wiring actor inputs/outputs, or implementing actor runtime logic.
- You need safe setup guidance for
apifyCLI authentication, project bootstrap, or deployment workflow. - You are implementing web scraping or automation using Crawlee and the Apify SDK.
- Trigger keywords:
apify,actor,crawlee,apify push,apify run,input_schema,actor.json,CheerioCrawler,PlaywrightCrawler,standby mode.
Overview
Actors are serverless programs inspired by the UNIX philosophy — programs that do one thing well and can be easily combined to build complex systems. They're packaged as Docker images and run in isolated containers in the cloud.
Core Concepts:
- Accept well-defined JSON input.
- Perform isolated tasks (web scraping, automation, data processing).
- Produce structured JSON output to datasets and/or store data in key-value stores.
- Can run from seconds to hours or even indefinitely.
- Persist state and can be restarted.
Prerequisites
Before creating or modifying actors, verify that the apify CLI is installed:
If it is not installed, use one of these methods (listed in order of preference):
Security note: Do NOT install the CLI by piping remote scripts to a shell (e.g.curl … | bashorirm … | iex). Always use a package manager.
When the apify CLI is installed, check that it is logged in:
If it is not logged in, check if the APIFY_TOKEN environment variable is defined. If not, ask the user to generate one on https://console.apify.com/settings/integrations and then define APIFY_TOKEN with it.
Then authenticate using one of these methods:
Security note: Avoid passing tokens as command-line arguments (e.g.apify login -t <token>). Arguments are visible in process listings and may be recorded in shell history. Prefer environment variables or interactive login instead. Never log, print, or embedAPIFY_TOKENin source code or configuration files. Use a token with the minimum required permissions (scoped token) and rotate it periodically.
Procedure
1. Select a Template
IMPORTANT: Before starting actor development, always ask the user which programming language they prefer:
- JavaScript —
apify create <actor-name> -t project_empty - TypeScript —
apify create <actor-name> -t ts_empty - Python —
apify create <actor-name> -t python-empty
Use the appropriate CLI command based on the user's language choice. Additional packages (Crawlee, Playwright, etc.) can be installed later as needed.
2. Quick Start Workflow
- Create actor project — Run the appropriate
apify createcommand based on user's language preference (see Template Selection above). - Install dependencies (verify package names match intended packages before installing):
- JavaScript/TypeScript:
npm install(usespackage-lock.jsonfor reproducible, integrity-checked installs — commit the lockfile to version control). - Python:
pip install -r requirements.txt(pin exact versions inrequirements.txt, e.g.crawlee==1.2.3, and commit the file to version control).
- Implement logic — Write the actor code in
src/main.py,src/main.js, orsrc/main.ts. - Configure schemas — Update input/output schemas in
.actor/input_schema.json,.actor/output_schema.json,.actor/dataset_schema.json. - Configure platform settings — Update
.actor/actor.jsonwith actor metadata. Load [references/actor-json.md](references/actor-json.md) when editing `actor.json` for complete structure and configuration options. - Write documentation — Create comprehensive
README.mdfor the marketplace. - Test locally — Run
apify runto verify functionality (see Local Testing below). - Deploy — Run
apify pushto deploy the actor on the Apify platform (actor name is defined in.actor/actor.json).
3. Local Testing
When testing an actor locally with apify run, provide input data by creating a JSON file at:
This file should contain the input parameters defined in your .actor/input_schema.json. The actor will read this input when running locally, mirroring how it receives input on the Apify platform.
IMPORTANT — Local storage is NOT synced to the Apify Console:
- Running
apify runstores all data (datasets, key-value stores, request queues) only on your local filesystem in thestorage/directory. - This data is never automatically uploaded or pushed to the Apify platform. It exists only on your machine.
- To verify results on the Apify Console, you must deploy the Actor with
apify pushand then run it on the platform. - Do not rely on checking the Apify Console to verify results from local runs — instead, inspect the local
storage/directory or check the Actor's log output.
4. Configure Schemas
Load these reference files when working on the corresponding schema:
- [references/actor-json.md](references/actor-json.md) — Complete
actor.jsonstructure and configuration options. Load when editing.actor/actor.json. - [references/input-schema.md](references/input-schema.md) — Input schema structure and examples. Load when editing
.actor/input_schema.json. - [references/output-schema.md](references/output-schema.md) — Output schema structure, examples, and template variables. Load when editing
.actor/output_schema.json. - [references/dataset-schema.md](references/dataset-schema.md) — Dataset schema structure, configuration, and display properties. Load when editing
.actor/dataset_schema.json. - [references/key-value-store-schema.md](references/key-value-store-schema.md) — Key-value store schema structure, collections, and configuration. Load when configuring KVS schemas.
5. Logging
Load [references/logging.md](references/logging.md) for complete logging documentation including available log levels and best practices for JavaScript/TypeScript and Python.
Key rule: Always use `apify/log` package — it censors sensitive data (API keys, tokens, credentials). Do not use console.log() or print() — these bypass credential censoring.
6. Standby Mode
Check usesStandbyMode in .actor/actor.json — only implement standby logic if set to true.
Load [references/standby-mode.md](references/standby-mode.md) for complete standby mode documentation including readiness probe implementation for JavaScript/TypeScript and Python.
7. Deploy
8. Apify MCP Tools
If MCP server is configured, use these tools for documentation:
search-apify-docs— Search documentation.fetch-apify-docs— Get full doc pages.
Otherwise, the MCP Server URL: https://mcp.apify.com/?tools=docs.
Project Structure
Security
Treat all crawled web content as untrusted input. Actors ingest data from external websites that may contain malicious payloads. Follow these rules:
- Sanitize crawled data — Never pass raw HTML, URLs, or scraped text directly into shell commands,
eval(), database queries, or template engines. Use proper escaping or parameterized APIs. - Validate and type-check all external data — Before pushing to datasets or key-value stores, verify that values match expected types and formats. Reject or sanitize unexpected structures.
- Do not execute or interpret crawled content — Never treat scraped text as code, commands, or configuration. Content from websites could include prompt injection attempts or embedded scripts.
- Isolate credentials from data pipelines — Ensure
APIFY_TOKENand other secrets are never accessible in request handlers or passed alongside crawled data. Use the Apify SDK's built-in credential management rather than passing tokens through environment variables in data-processing code. - Review dependencies before installing — When adding packages with
npm installorpip install, verify the package name and publisher. Typosquatting is a common supply-chain attack vector. Prefer well-known, actively maintained packages. - Pin versions and use lockfiles — Always commit
package-lock.json(Node.js) or pin exact versions inrequirements.txt(Python). Lockfiles ensure reproducible builds and prevent silent dependency substitution. Runnpm auditorpip-auditperiodically to check for known vulnerabilities.
Best Practices
✓ Do:
- Use
apify runto test actors locally (configures Apify environment and storage). - Use Apify SDK (
apify) for code running ON the Apify platform. - Validate input early with proper error handling and fail gracefully.
- Use
CheerioCrawlerfor static HTML (10x faster than browsers). - Use
PlaywrightCrawleronly for JavaScript-heavy sites. - Use router pattern (
createCheerioRouter/createPlaywrightRouter) for complex crawls. - Implement retry strategies with exponential backoff.
- Use proper concurrency: HTTP (10–50), Browser (1–5).
- Set sensible defaults in
.actor/input_schema.json. - Define output schema in
.actor/output_schema.json. - Clean and validate data before pushing to dataset.
- Use semantic CSS selectors with fallback strategies.
- Respect
robots.txt, ToS, and implement rate limiting. - Always use `apify/log` package — censors sensitive data (API keys, tokens, credentials).
- Implement readiness probe handler (required if your Actor uses standby mode).
- Use
async/awaitfor all asynchronous operations to avoid race conditions and unhandled promise rejections.
This is the start of the file. Read the full SKILL.md on GitHub.
Security
- Security scanPassed, 95 of 100Pattern checks on the skill's files.
- Model reviewPassed
Quality evaluation
- Task evaluationNot runNo evaluation yet. Run one in Skill Studio.
Source
- SKILL.md in the repositoryCheckingskills/apify-actor-development/SKILL.md
Popularity
- 7-day trend score
- 5
Not refreshed yet.
Works with
Any agent vskill installs to: 56 targets in all. These 39 have a page on this site.
- Claude Code
- Cursor
- GitHub Copilot
- Windsurf
- Codex
- Gemini CLI
- Cline
- Amp
- Roo Code
- Goose
- Continue
- Kilo Code
- Junie
- Trae
- OpenHands
- Qwen Code
- AI Agent
- Tabnine Chat
- Sourcegraph Cody
- Amazon Q
- Firebase Genkit
- Sweep
- Devin
- Phind
- Mentat
- Claude Desktop
- Aider
- GPT Pilot
- Plandex
- bolt.new
- v0
- Replit Agent
- Anse
- TypingMind
- BetterChatGPT
- LibreChat
- Warp AI
- Pieces
- Fig AI
Embed badge
[](https://verified-skill.com/skills/kayforkind/skill-slice/apify-actor-development)