Generated banner for Apify Actorization
Generated logo for Apify Actorization

Apify Actorization

ApifyOfficialPublished by Apify

  • Skill
  • Tool integration
  • Cloud and DevOps
  • Apache-2.0
  • Medium risk

From the author

Convert existing projects into Apify Actors - serverless cloud programs. Actorize JavaScript/TypeScript (SDK with Actor.init/exit), Python (async context manager), or any language (CLI wrapper). Use when migrating code to Apify, wrapping CLI tools as Actors, or adding Actor SDK to existing projects.
— the description by Apify

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

Apify Actorization provides a structured process for transforming local scripts, CLI tools, or web applications into serverless cloud programs known as Actors. By integrating the Apify SDK or utilizing CLI wrappers, developers can package their code as Docker images that run on the Apify platform. This skill covers the entire lifecycle from project analysis and environment initialization to schema configuration, local testing, and final deployment, ensuring that applications are ready for cloud execution and potential monetization.

What it does

  • Initializes project structures for Apify platform compatibility
  • Integrates the Apify SDK for JavaScript, TypeScript, and Python
  • Provides wrapper patterns for CLI tools and languages without native SDK support
  • Configures input and output schemas for structured data handling
  • Facilitates local testing and debugging of cloud-ready applications
  • Guides the creation of documentation for Apify Store listings

When to use it

  • When migrating an existing local script or application to the Apify cloud platform
  • When you need to wrap a CLI tool as a reusable serverless service
  • When adding Apify SDK capabilities to a Crawlee project
  • When preparing an application for deployment and potential monetization on the Apify Store

Advantages

  • Enables serverless execution of custom code in the cloud
  • Standardizes input and output handling via JSON schemas
  • Supports diverse languages through SDKs or CLI wrappers
  • Provides built-in tools for local testing and environment simulation
  • Simplifies the path to publishing and monetizing tools on the Apify Store

Usage examples

“How do I start converting my existing Node.js project into an Apify Actor?”
The agent will guide you to run the apify init command, install the apify package, and wrap your main execution logic with Actor.init and Actor.exit lifecycle methods.
“I have a Python script I want to run on Apify, what are the steps?”
The agent will instruct you to create a Dockerfile, use the async context manager async with Actor, and configure your input schema for the platform.
“How can I wrap a Go CLI tool as an Apify Actor?”
The agent will explain how to create a shell wrapper script that uses the apify-cli to fetch input, execute your binary, and push results to the dataset.
“What is the best way to test my Actor before deploying it?”
The agent will recommend using the apify run command with specific input flags to simulate the platform environment locally.

Install

  1. Download the skill as a ZIP:

    https://autogineer.com/agent-skills/apify/apify-actorization/download
  2. Unzip it into the cross-client skills folder of your project:

    mkdir -p .agents/skills && unzip apify-actorization.zip -d .agents/skills

Documentation by Apify

Apify Actorization

Actorization converts existing software into reusable serverless applications compatible with the Apify platform. Actors are programs packaged as Docker images that accept well-defined JSON input, perform an action, and optionally produce structured JSON output.

Quick start

  1. Run apify init <actor-name> --user-agent apify-agent-skills/apify-actorization in project root

  2. Create a Dockerfile for the project's language

  3. Wrap code with SDK lifecycle (see language-specific section below)

  4. Configure .actor/input_schema.json

  5. Test with apify run --input '{"key": "value"}' --user-agent apify-agent-skills/apify-actorization

  6. Deploy with apify push --user-agent apify-agent-skills/apify-actorization

When to use this skill

  • Converting an existing project to run on the Apify platform

  • Adding Apify SDK integration to a project

  • Wrapping a CLI tool or script as an Actor

  • Migrating a Crawlee project to Apify

Prerequisites

Verify apify CLI is installed:

apify --help

If not installed, use one of these methods (listed in order of preference):

# Preferred: install via a package manager (provides integrity checks)
npm install -g apify-cli

# Or (Mac): brew install apify-cli

Security note: Do NOT install the CLI by piping remote scripts to a shell (e.g. curl ... | bash or irm ... | iex). Always use a package manager.

Verify CLI is logged in:

apify info  # Should return your username

If not logged in, authenticate using OAuth (opens browser):

apify login

If browser login isn't available (headless environment or CI), ensure the APIFY_TOKEN environment variable is exported (note: the variable is APIFY_TOKEN, not APIFY_API_TOKEN). The CLI reads it automatically - no explicit login needed. If the user doesn't have a token, generate one at https://console.apify.com/settings/integrations.

Apify platform environment: When the Actor runs on the Apify platform, APIFY_TOKEN is auto-injected as an environment variable and the Apify SDK reads it automatically — you do not need to pass it explicitly. Locally, apify login stores credentials in ~/.apify and the SDK uses them.

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 OAuth login or environment variables instead. Never log, print, or embed APIFY_TOKEN in source code or configuration files. Use a token with the minimum required permissions (scoped token) and rotate it periodically.

Telemetry attribution (required)

Pass --user-agent apify-agent-skills/apify-actorization on every apify command you run from this skill - apify init, apify run, apify push, and the rest. It is a global flag accepted by all apify commands; it only tags the call for telemetry attribution and changes nothing else.

apify push --user-agent apify-agent-skills/apify-actorization

Actorization checklist

Copy this checklist to track progress:

  • [ ] Step 1: Analyze project (language, entry point, inputs, outputs)

  • [ ] Step 2: Run apify init <actor-name> --user-agent apify-agent-skills/apify-actorization and create a Dockerfile

  • [ ] Step 3: Apply language-specific SDK integration

  • [ ] Step 4: Configure .actor/input_schema.json

  • [ ] Step 5: Configure .actor/output_schema.json (if applicable)

  • [ ] Step 6: Update .actor/actor.json metadata

  • [ ] Step 7: Write README.md for Apify Store listing

  • [ ] Step 8: Test locally with apify run --user-agent apify-agent-skills/apify-actorization

  • [ ] Step 9: Deploy with apify push --user-agent apify-agent-skills/apify-actorization

Step 1: Analyze the project

Before making changes, understand the project:

  1. Identify the language - JavaScript/TypeScript, Python, or other

  2. Find the entry point - The main file that starts execution

  3. Identify inputs - Command-line arguments, environment variables, config files

  4. Identify outputs - Files, console output, API responses

  5. Check for state - Does it need to persist data between runs?

Step 2: Initialize Actor structure

Run in the project root, passing a DNS-friendly Actor name (e.g. my-scraper):

apify init <actor-name> --user-agent apify-agent-skills/apify-actorization

The name passed as an argument keeps apify init from prompting; without it, the command waits for input and hangs in non-interactive shells.

apify init sets up .actor/actor.json and local storage/, but no Dockerfile. Without one, the platform builds on its default Node.js image, so a Python Actor builds cleanly and then fails at runtime. Create a Dockerfile whose base image matches the project's language (apify/actor-python for Python, apify/actor-node for JavaScript/TypeScript) at .actor/Dockerfile, in the project root, or at the path set in the dockerfile field of .actor/actor.json.

Step 3: Apply language-specific changes

Choose based on your project's language:

Quick reference
LanguageInstallWrap Code
JS/TSnpm install apifyawait Actor.init() ... await Actor.exit()
Pythonpip install apifyasync with Actor:
OtherUse CLI in wrapper scriptapify actor:get-input / apify actor:push-data

Steps 4-6: Configure schemas

See schemas-and-output.md for detailed configuration of:

  • Input schema (.actor/input_schema.json)

  • Output schema (.actor/output_schema.json)

  • Actor configuration (.actor/actor.json)

  • State management (request queues, key-value stores)

Validate schemas against @apify/json_schemas npm package.

Step 7: Write README

IMPORTANT: Always generate a README.md as part of actorization. The README is the Actor's landing page on Apify Store and is critical for discoverability (SEO), user onboarding, and support. Do not consider an Actor complete without a proper README.

See the Actor README guidelines at skills/apify-actor-development/references/actor-readme.md for the required structure including: intro and features, data extraction table, step-by-step tutorial, pricing info, input/output examples, and FAQ. Aim for at least 300 words with SEO-optimized H2/H3 headings. Also review these top Actors for best practices:

Step 8: Test locally

Run the Actor with inline input (for JS/TS and Python Actors):

apify run --input '{"startUrl": "https://example.com", "maxItems": 10}' --user-agent apify-agent-skills/apify-actorization

Or use an input file:

apify run --input-file ./test-input.json --user-agent apify-agent-skills/apify-actorization

Important: Always use apify run, not npm start or python main.py. The CLI sets up the proper environment and storage.

Step 9: Deploy

apify push --user-agent apify-agent-skills/apify-actorization

This uploads and builds your Actor on the Apify platform.

Monetization (optional)

After deploying, you can monetize your Actor in Apify Store. The recommended model is Pay Per Event (PPE):

  • Per result/item scraped

  • Per page processed

  • Per API call made

Configure PPE in Apify Console under Actor > Monetization. Charge for events in your code with await Actor.charge('result').

Other options: Rental (monthly subscription) or Free (open source).

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_TOKEN and 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 install or pip 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 in requirements.txt (Python). Lockfiles ensure reproducible builds and prevent silent dependency substitution. Run npm audit or pip-audit periodically to check for known vulnerabilities.

Pre-deployment checklist

  • [ ] .actor/actor.json exists with correct name and description

  • [ ] .actor/actor.json validates against @apify/json_schemas (actor.schema.json)

  • [ ] .actor/input_schema.json defines all required inputs

  • [ ] .actor/input_schema.json validates against @apify/json_schemas (input.schema.json)

  • [ ] .actor/output_schema.json defines output structure (if applicable)

  • [ ] .actor/output_schema.json validates against @apify/json_schemas (output.schema.json)

  • [ ] Dockerfile is present and builds successfully

  • [ ] Actor.init() / Actor.exit() wraps main code (JS/TS)

  • [ ] async with Actor: wraps main code (Python)

  • [ ] Inputs are read via Actor.getInput() / Actor.get_input()

  • [ ] Outputs use Actor.pushData() or key-value store

  • [ ] apify run --user-agent apify-agent-skills/apify-actorization executes successfully with test input

  • [ ] README.md exists with proper structure (intro, features, data table, tutorial, pricing, input/output examples)

  • [ ] generatedBy is set in actor.json meta section

MCP tools

Apify MCP

If the Apify 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.

Playwright MCP (debugging)

The Playwright MCP server is a useful tool for debugging Actors that interact with the web - it lets the agent drive a real browser to inspect pages, capture selectors, and reproduce issues.

Install with the Claude Code CLI:

claude mcp add playwright npx @playwright/mcp@latest

Or add it manually to your MCP config:

{
  "mcpServers": {
    "playwright": {
      "command": "npx",
      "args": ["@playwright/mcp@latest"]
    }
  }
}

Resources

Files

LICENSE

Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/

TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION

1. Definitions.

"License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document.

"Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License.

"Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.

"You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License.

"Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files.

"Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types.

"Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below).

"Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof.

"Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution."

"Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work.

2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form.

3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed.

4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions:

     (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and

     (b) You must cause any modified files to carry prominent notices stating that You changed the files; and

     (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and

     (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License.

     You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License.

5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions.

6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file.

7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License.

8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages.

9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability.

END OF TERMS AND CONDITIONS

APPENDIX: How to apply the Apache License to your work.

To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!)  The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives.

Copyright [yyyy] [name of copyright owner]

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

Requirements and compatibility

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Needs: Needs an MCP server, Needs Python, Needs Node.js

Security

What our scanner noticed· Medium risk

  • Instructions that use the network
  • Downloads piped into a shell

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

Published by
Apify
Publisher
Apify (Official)
Source
apify/agent-skills · skills/apify-actorization · commit f22557f
Licence
Apache License 2.0 (redistribution allowed)
  • LICENSE (written by AutoGineer)
  • ATTRIBUTION.md (written by AutoGineer)
Synced

AutoGineer is not affiliated with or endorsed by Apify or Apify.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download apify-actorization.zip