New: 97,000+ skills indexed from GitHub repos with 100+ stars · every skill safety-checkedBrowse top skillsTop skills
Esc to closeBrowse all skills
Submit a skillBrowse skills
Submit a skillBrowse skills

Agent skill

Apify Actorization

by sickn33 in sickn33/agentic-awesome-skills

Actorization converts existing software into reusable serverless applications compatible with the Apify platform.

MITAuto-check passedData & Analytics

Install Apify Actorization

skills CLI
$ npx skills add sickn33/agentic-awesome-skills --skill apify-actorization -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install sickn33/agentic-awesome-skills apify-actorization --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/sickn33/agentic-awesome-skills.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/apify-actorization .claude/skills/apify-actorization && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
apify-actorization
GitHub stars
47k
Used in
2 other repos
Token cost
~1.7k tokens
SKILL.md length
685 words
Files
5 (incl. references)
Skills in repo
1,394
Repo updated
First seen
Licence
MIT

At a glance

Actorization converts existing software into reusable serverless applications compatible with the Apify platform.

  • Works in 5 steps: Analyze the Project → Initialize Actor Structure → Apply Language-Specific Changes → …
  • Tasks that involve Web scraping
  • SKILL.md covers Quick Start, When to Use This Skill, Prerequisites and Actorization Checklist, plus 11 more sections
  • Calls npm, brew and pip; reaches mcp.apify.com; needs APIFY_TOKEN

What it does

Apify Actorization is an agent skill from sickn33/agentic-awesome-skills. 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.

Its SKILL.md is about 1.7k tokens, which your agent loads only when the skill is triggered. The skill folder holds 5 other files, including reference files (for example `references/cli-actorization.md`, `references/js-ts-actorization.md` and `references/python-actorization.md`).

It sits in Data & Analytics, covering Web scraping and Serverless. It works with Apify and Docker. The repository describes itself as: AAS Core is the local, agent-first control plane for complete catalog discovery, agent-owned selection, stack validation, and planning, backed by 2,400+ agentic skills. Includes… The licence is MIT.

When your agent uses it

  • Tasks that involve Web scraping
  • Tasks that involve Serverless

Example prompts

  • “/apify-actorization”

Requirements

  • Python 3
  • Node.js
  • Docker
  • A credential in APIFY_TOKEN

Workflow steps

5 steps, taken from the step headings in SKILL.md.

  1. Analyze the Project
  2. Initialize Actor Structure
  3. Apply Language-Specific Changes
  4. Test Locally
  5. Deploy

What it can do on your machine

Read from SKILL.md and the folder at commit 1e53ce2. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Shell commands in SKILL.md call:

    • npm
    • brew
    • pip
    • python

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    Hosts in commands or code, which the agent is likely to contact:

    • mcp.apify.com

    Also links to:

    • docs.apify.com
    • console.apify.com
    • raw.githubusercontent.com

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names these keys or tokens, usually read from environment variables:

    • APIFY_TOKEN

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Apify Actorization loads about 1.7k tokens when it runs, and up to ~4.6k if it reads all its reference files. Until then it costs about 70 tokens; SKILL.md has 685 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~70
When it runs · the whole SKILL.md, loaded when a task matches
~1.7k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~4.6k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from sickn33/agentic-awesome-skills at commit 1e53ce2, republished under its MIT licence (© sickn33). 685 words, ~1,713 tokens.

Download SKILL.mdSave it as .claude/skills/apify-actorization/SKILL.md (or your agent's skills folder). This skill also uses 4 other files; get the full folder from GitHub.
name
apify-actorization
description
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.
risk
critical
source
community
date_added
2026-09-04

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 in project root
  2. Wrap code with SDK lifecycle (see language-specific section below)
  3. Configure .actor/input_schema.json
  4. Test with apify run --input '{"key": "value"}'
  5. Deploy with apify push

When to Use This Skill

  • Converting an existing project to run on 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:

bash
apify --help

If not installed:

bash
brew install apify-cli

# Or: npm install -g apify-cli
# Or install from an official release package that your OS package manager verifies

Verify CLI is logged in:

bash
apify info  # Should return your username

If not logged in, check if APIFY_TOKEN environment variable is defined. If not, ask the user to generate one at https://console.apify.com/settings/integrations, add it to their shell or secret manager without putting the literal token in command history, then run:

bash
apify login

Actorization Checklist

Copy this checklist to track progress:

  • Step 1: Analyze project (language, entry point, inputs, outputs)
  • Step 2: Run apify init to create Actor structure
  • 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: Test locally with apify run
  • Step 8: Deploy with apify push

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:

bash
apify init

This creates:

  • .actor/actor.json - Actor configuration and metadata
  • .actor/input_schema.json - Input definition for the Apify Console
  • Dockerfile (if not present) - Container image definition

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.

Show full SKILL.md (291 more words)Show less

Step 7: Test Locally

Run the actor with inline input (for JS/TS and Python actors):

bash
apify run --input '{"startUrl": "https://example.com", "maxItems": 10}'

Or use an input file:

bash
apify run --input-file ./test-input.json

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

Step 8: Deploy

bash
apify push

This uploads and builds your actor on the Apify platform.

Monetization (Optional)

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

  • Per result/item scraped
  • Per page processed
  • Per API call made

Configure PPE in the 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).

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 executes successfully with test input
  • generatedBy is set in actor.json meta section

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.

Resources

Limitations

  • Use this skill only when the task clearly matches the scope described above.
  • Do not treat the output as a substitute for environment-specific validation, testing, or expert review.
  • Stop and ask for clarification if required inputs, permissions, safety boundaries, or success criteria are missing.

© sickn33, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 4 other files (references) in skills/apify-actorization of sickn33/agentic-awesome-skills.

  • SKILL.md
  • references/cli-actorization.md
  • references/js-ts-actorization.md
  • references/python-actorization.md
  • references/schemas-and-output.md

Open the folder on GitHubat commit 1e53ce2

Used in 2 other repositories

We found 11 copies of this SKILL.md (exact, near-identical or edited) in other folders, from 2 other GitHub owners. This page covers the copy in sickn33/agentic-awesome-skills, which our catalogue first saw on October 7, 2026.

Compare with similar skills

Apify Actorization next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Apify Actorization compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Apify Actorization this skillsickn33/agentic-awesome-skills47k2 repos~1.7kAutomated safety check: PassMIT
Apify Actor Developmentapify/agent-skills2.4k—~2.9kAutomated safety check: PassNone
Scraper Builderjwynia/agent-skills165—~4kAutomated safety check: PassMIT
Hacker News Scrapermajiayu000/claude-skill-registry6662 repos~538Automated safety check: PassMIT
Upgrading Mwaa Environmentsaws/agent-toolkit-for-aws2.8k—~7.3kAutomated safety check: PassApache-2.0
Google Maps ScraperMahanaicoach/google-maps-scraper-kit1.3k—~2.8kAutomated safety check: PassMIT

Similar skills

  • Apify Actor Development

    apify/agent-skills

    Official

    Creates, changes, debugs and deploys Apify Actors, including their input and output schemas, using the Apify CLI.

    2.4k GitHub stars~2.9k tokensUpdated yesterday
    Data & AnalyticsAuto-check passed

  • Scraper Builder

    jwynia/agent-skills

    Guide AI agents to generate complete PageObject pattern web scraper projects using Playwright and TypeScript with Docker deployment.

    165 GitHub stars~4k tokensUpdated 7 mo ago
    Data & AnalyticsAuto-check passed

  • Hacker News Scraper

    majiayu000/claude-skill-registry

    Search Hacker News stories and comments using the free Algolia API.

    666 GitHub starsUsed in 2 repos~538 tokens
    Data & AnalyticsAuto-check passed

  • Upgrading Mwaa Environments

    aws/agent-toolkit-for-aws

    Official

    Upgrades an MWAA environment to a newer Airflow version — within 2.x, within 3.x, or across the 2.x-to-3.x boundary.

    2.8k GitHub stars~7.3k tokensUpdated today
    Data & AnalyticsAuto-check passed

  • Google Maps Scraper

    Mahanaicoach/google-maps-scraper-kit

    Scrape Google Maps business listings (name, address, phone, website, rating, reviews, lat/lng, hours, emails) via the local gosom google-maps-scraper REST API.

    1.3k GitHub stars~2.8k tokensUpdated 2 days ago
    Data & AnalyticsAuto-check passed

  • Apify CLI

    apify/apify-cli

    Official

    Patterns for invoking the Apify CLI (apify) from agents. An agent skill from apify/apify-cli.

    255 GitHub stars~1.5k tokensUpdated yesterday
    Data & AnalyticsAuto-check passed

More from sickn33/agentic-awesome-skills

All 1,394 skills in this repo

  • Liuguang Banlan UI

    sickn33/agentic-awesome-skills

    Implements an interface in one of two named color modes, iridescent white or colorful black, from a parameterized starter that reports measured color intensity.

    47k GitHub starsUsed in 1 repo~2.5k tokens
    Auto-check passed

  • User Thoughts Memory

    sickn33/agentic-awesome-skills

    Saves a user's project decisions, rules and preferences into a project-local mdbase so later sessions and other agents can recover the intent.

    47k GitHub starsUsed in 1 repo~2.5k tokens
    Auto-check passed

  • Using LWC Memory and Graphs

    sickn33/agentic-awesome-skills

    Keeps project decisions, research and verified results available across coding-agent sessions through LWC memory, a document Wiki graph and a CodeGraph code index.

    47k GitHub starsUsed in 1 repo~2k tokens
    Auto-check passed

  • Find Complementary Founders

    sickn33/agentic-awesome-skills

    Guides an agent through assessing its own owner for cofounder fit, publishing an approved profile, and ranking complementary profiles other agents published for their owners.

    47k GitHub starsUsed in 1 repo~4.8k tokens
    Auto-check passed

  • Whatsapp Cloud API

    sickn33/agentic-awesome-skills

    Integracao com WhatsApp Business Cloud API (Meta). An agent skill from sickn33/agentic-awesome-skills.

    47k GitHub starsUsed in 2 repos~4.5k tokens
    Auto-check passed

  • Cline Pilot

    sickn33/agentic-awesome-skills

    Acts as a proxy for the Cline CLI, dispatching coding tasks one at a time, monitoring runs by hard evidence, relaying decisions to you and learning per-project preferences.

    47k GitHub starsUsed in 1 repo~4.6k tokens
    Auto-check passed

Works with

Categories

Questions about Apify Actorization

What does Apify Actorization do?

Actorization converts existing software into reusable serverless applications compatible with the Apify platform. Apify Actorization is an agent skill from sickn33/agentic-awesome-skills. Actorization converts existing software into reusable serverless applications compatible with the Apify platform.

When should I use Apify Actorization?

Apify Actorization fits situations like: tasks that involve Web scraping; tasks that involve Serverless.

How do I install Apify Actorization in Claude Code?

Run `npx skills add sickn33/agentic-awesome-skills --skill apify-actorization -a claude-code`. Or copy the skill folder (skills/apify-actorization in sickn33/agentic-awesome-skills) into .claude/skills/apify-actorization in your project. Claude Code loads it when a task matches its description.

How do I install Apify Actorization in Codex?

Run `npx skills add sickn33/agentic-awesome-skills --skill apify-actorization -a codex`. Or copy the skill folder (skills/apify-actorization in sickn33/agentic-awesome-skills) into .agents/skills/apify-actorization in your project. Codex loads it when a task matches its description.

Can I use Apify Actorization in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add sickn33/agentic-awesome-skills --skill apify-actorization -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/apify-actorization, .gemini/skills/apify-actorization, .github/skills/apify-actorization and .opencode/skills/apify-actorization in your project.

What does Apify Actorization need to run?

Going by SKILL.md and its folder, Apify Actorization needs the command-line tools its instructions call (npm, brew, pip and python) and credentials named APIFY_TOKEN. Our summary lists: Python 3; Node.js; Docker; A credential in APIFY_TOKEN.

Does Apify Actorization access the network?

SKILL.md names 4 domains. In commands or code: mcp.apify.com; the agent is likely to contact it when it follows the instructions. As links in the text: docs.apify.com, console.apify.com and raw.githubusercontent.com. This is read from the text; nothing was executed.

Is Apify Actorization safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Apify Actorization use?

Apify Actorization is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Apify Actorization use?

About 1.7k tokens (SKILL.md is roughly 6.9k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 2.9k tokens, read only when the agent opens those files.

What are the alternatives to Apify Actorization?

Skills that share tags, products or a category with Apify Actorization: Apify Actor Development (apify/agent-skills, 2.4k stars), Scraper Builder (jwynia/agent-skills, 165 stars), Hacker News Scraper (majiayu000/claude-skill-registry, 666 stars) and Upgrading Mwaa Environments (aws/agent-toolkit-for-aws, 2.8k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Apify Actorization?

sickn33 (a GitHub user) maintains it in sickn33/agentic-awesome-skills, which has 47,304 GitHub stars. The repository holds 1,394 skills in this directory. The repository was last updated on October 6, 2026.

Source: sickn33/agentic-awesome-skills on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.