Guide · Agent skill

How to use the Apify Actorization agent skill

Updated 2026-10-29 · written with AI from the project's own documentation and checked against our catalogue data

The apify-actorization skill teaches an AI agent how to convert existing code, such as a scraper, crawler, CLI tool or script, into an Apify Actor. An Actor is a program packaged as a Docker image that accepts structured JSON input, performs an action, and can return structured JSON output. This guide explains what the skill does, how to install it, how to ask for it in plain language, and what to check before deploying anything to a real Apify account.

Apify Actorizationsickn33/agentic-awesome-skills · MIT Download the skill

Quick start

1Download and unzip the skill. Download the apify-actorization ZIP from this page and unzip it so the skill folder is available.
2Place the skill folder. Move the unzipped folder into ~/.claude/skills/ for personal use or into a project's .claude/skills/ folder, or upload the ZIP under Settings → Capabilities → Skills in the Claude apps.
3Install and log in to the Apify CLI. Install apify-cli with Homebrew or npm, then confirm login with apify info. If needed, store your APIFY_TOKEN securely and run apify login.
4Ask the agent to actorize your project. Describe the existing code, its inputs and outputs, and the goal of running it as an Apify Actor.
5Initialize and wrap the code. Let the agent run apify init and add the Apify SDK lifecycle calls for your language.
6Test locally. Run apify run with synthetic test input and confirm the output is correct.
7Review and deploy. Check the account, licence, secrets and network targets, then run apify push only after you approve it.

What the apify-actorization skill makes the agent do

An agent skill is a folder of instructions (a SKILL.md file plus reference files) that an AI agent loads when a task matches it. With this skill installed, the agent knows how to wrap an existing script, CLI tool, or Crawlee/SDK project so it runs on the Apify platform as an Actor.

The skill walks the agent through analysing the project (language, entry point, inputs, outputs, and state), running apify init, adding SDK lifecycle calls, writing input and output schema files, testing locally with apify run, and deploying with apify push.

Works with JavaScript/TypeScript (Apify SDK via npm install apify), Python (pip install apify), or CLI-based code in other languages using a wrapper script.
Configures .actor/input_schema.json, .actor/output_schema.json and .actor/actor.json.
Checks account, licence, secrets, network targets and spending limits before deploying or monetizing.

Install the apify-actorization skill

Download the skill ZIP from this page and unzip it. You can install it in one of two ways: place the unzipped skill folder in ~/.claude/skills/ to make it available for your user, or in a project's .claude/skills/ folder to make it available only inside that project.

If you use the Claude apps instead, upload the ZIP under Settings → Capabilities → Skills.

Personal install: ~/.claude/skills/
Project install: .claude/skills/ inside your project root
Claude apps: Settings → Capabilities → Skills, then upload the ZIP

Install the tools the skill needs

The skill assumes a working project and command-line tools. Before the agent can do much, you need the Apify CLI, an Apify account with an API token, and Docker. The Apify SDK is installed per language by the agent as part of the conversion.

The skill first checks whether the CLI is installed and logged in. If you are not logged in, it asks you to create a token in the Apify Console and store it in an environment variable or secret manager rather than pasting it into command history.

Apify CLI (apify-cli), installed via Homebrew (brew install apify-cli) or npm (npm install -g apify-cli)
Apify account and API token (APIFY_TOKEN) for login and deployment
Docker, since the Dockerfile is built on the platform and can be tested locally
Apify SDK for JavaScript (npm install apify) or Python (pip install apify)

apify --help
apify info  # Should return your username
apify login

Trigger the skill with natural requests

You do not need to name a command. Describe the task in plain language, and the agent should load the skill when your request matches its scope. Good requests name the existing code and the goal, for example: converting an existing project to run on the Apify platform, adding Apify SDK integration, wrapping a CLI tool or script as an Actor, or migrating a Crawlee project to Apify.

Be specific about what the code takes in and returns. The agent needs to know the input fields for the input schema and what the output should look like.

"Wrap this Crawlee scraper in ./crawler as an Apify Actor. Use startUrl and maxItems as inputs and push results to the dataset."
"Add Apify SDK integration to this Python script so it reads its input from Apify and pushes rows to a dataset."
"Wrap my Go CLI tool as an Actor with a shell wrapper script."

Follow the workflow: test locally before deploying

The skill's core workflow is: run apify init, wrap the code, configure the schemas, test, then deploy. Testing uses inline input for JavaScript/TypeScript and Python Actors, or an input file for any language.

Deployment uploads and builds the Actor on the Apify platform, so only run it once you are satisfied with the local test and have confirmed the target account.

Run apify init in the project root to create .actor/actor.json, .actor/input_schema.json and a Dockerfile if one is missing.
Test with apify run --input or apify run --input-file ./test-input.json.
Deploy with apify push only after review.

apify init
apify run --input '{"startUrl": "https://example.com", "maxItems": 10}'
apify run --input-file ./test-input.json
apify push

Safety notes: scripts, network and publishing

This skill runs scripts and uses the network. Local test runs can make network requests or use cloud storage if you have configured it, so the skill recommends synthetic fixtures and a test account. Before initialization, install or deploy, the agent is told to inspect existing files, confirm the target account or Actor, the source licence, uploaded files and secrets, network targets, and spending or charging limits.

Local approval is not cloud approval. Agreeing to a local conversion does not authorise uploading code, publishing to the Apify Store, or setting up monetization. The skill can upload code, publish to the Store and set paid charging events, so those actions need your explicit approval. Do not give the agent a project with unclear licensing or embedded secrets, because publishing would expose the code or credentials.

Pin the SDK, CLI and base image versions you have reviewed, and verify schemas against that version.
Keep secrets out of the project and out of logs. The JS and Python templates warn against logging full input.
Monetization is optional. The skill describes Pay Per Event charging (for example await Actor.charge('result')) and asks you to configure it in the Apify Console under Actor > Monetization.

Tips for better results

Give the agent a clean, working project before you start. The workflow assumes the code already runs, so fix obvious build errors first. Name the entry point and the inputs you want exposed, because the input schema is built from them.

Review the generated schema files and the pre-deployment checklist in SKILL.md before running apify push. If the agent needs current Apify documentation, the skill points to the Apify MCP docs tools when an MCP server is configured.

Start with one small input, such as a single URL, and a low maxItems for local tests.
Check that Actor.init() / Actor.exit() (JS/TS) or async with Actor: (Python) wraps your main code.
Read the Actorization Academy and the Apify CLI reference at docs.apify.com when you want background.

What people use it for

Turning a Crawlee scraper into a reusable Actor that takes a start URL and item limit as JSON input.
Wrapping a Python script so it reads its settings from Actor input and pushes rows to a dataset.
Packaging a Go, Rust or Java command-line tool behind a shell wrapper that reads input and stores output.
Migrating an existing Crawlee project to the Apify platform while keeping its logic unchanged.

Frequently asked questions

What is the apify-actorization skill?

It is an agent skill, a set of instructions an AI agent loads, that teaches the agent to convert existing software into an Apify Actor. The Actor is a Docker-packaged program that takes structured JSON input and can return structured JSON output.

How do I install the apify-actorization skill?

Download the ZIP from this page and unzip it into ~/.claude/skills/ for personal use or into a project's .claude/skills/ folder. In the Claude apps, you can upload the ZIP under Settings → Capabilities → Skills.

What do I need before using it?

You need the Apify CLI (apify-cli) installed via Homebrew or npm, an Apify account with an API token (APIFY_TOKEN) for login and deployment, and Docker. You also need the Apify SDK for JavaScript (npm install apify) or Python (pip install apify), depending on your language.

Is the apify-actorization skill free and what is its licence?

The source for this skill is listed under the MIT licence. The skill itself does not set prices, and the Apify platform and any charging you set up on your own Actors are separate matters that the skill asks you to review before deploying.

Will the skill publish my code to the Apify Store automatically?

No. The skill can upload code, publish to the Store and set paid charging events, but these actions need explicit user approval. Approving a local conversion does not approve cloud upload or monetization.

Can I use it with languages other than JavaScript and Python?

Yes. For languages without an SDK, such as Go, Rust or Java, the skill uses a wrapper script that calls the Apify CLI to get input and push output.

How is this different from the Apify SDK or the Apify CLI alone?

The SDK and CLI are the tools that do the work. This skill gives an AI agent the procedure and checks for using them to convert your project, including schema files, local testing and pre-deployment review.

New agent skills, repos and AI tools — every week

The best new skills and open-source projects, the fastest-growing repos, and one free prompt. Five minutes to read. Unsubscribe anytime.

Our verdict

Use this skill if you already have a scraper, crawler or script and want an AI agent to help package it as an Apify Actor, with a review step before anything goes to your Apify account. Pick something else if you have no code to package, if you want a no-code scraping tool, or if your project has unclear licensing or embedded secrets that you are not ready to clean up.

Download the skill