apify/agent-skills: giving coding agents Apify platform knowledge

The gap these skills fill for Apify users

An AI coding agent that has never seen the Apify platform will happily write a scraper from scratch, pick the wrong Actor, or invent input fields. The repository's stated purpose is to close that gap: the README describes the skills as "Production-grade web scraping and automation skills for AI coding agents", installed into Claude Code, Cursor, Windsurf, Codex or Gemini CLI. The target reader is someone already using an agent for development work who wants that agent to operate the Apify marketplace, which the README calls "the marketplace for web data and AI tools".

The five skills split along a real boundary. `apify-ultimate-scraper` is for consuming the platform: the README says it covers 130+ curated Actors across Instagram, Facebook, TikTok, YouTube, X, LinkedIn, Reddit, Google Maps, Google Search, Google Trends, Amazon, Walmart, eBay, Booking.com, TripAdvisor, Airbnb, Yelp, Telegram, Snapchat and GitHub, and falls back to searching the full Apify Store when a platform is not covered. The other four are for producing things on the platform: `apify-actor-development` for new Actors in JavaScript, TypeScript or Python, `apify-actorization` for wrapping existing code, `apify-generate-output-schema` for deriving schema files from source, and `apify-integration-development` for building an official integration into someone else's product. A team doing lead generation needs the first; a team shipping an Apify integration into their own SaaS needs the last.

How the skills are structured and what the agent actually reads

These are not libraries you import. They are instruction bundles the agent loads, and the repository layout confirms that: the top level holds `skills/`, `commands/`, `agents/` and `gemini-extension.json`, with a `.claude-plugin/` directory for the Claude Code plugin path. Each skill lives in its own subdirectory under `skills/`.

The README is explicit that the actor-development skill ships "bundled references" covering `actor.json`, input, output, dataset and key-value schemas, logging, and standby mode. That matters more than the skill count. An agent asked to scaffold an Actor without those references will guess at the manifest shape; with them, it has a document to follow. The schema-generation skill works the other way round, reading an existing Actor's source and deriving `dataset_schema.json`, `output_schema.json` and `key_value_store_schema.json` from what it finds.

The integration skill is the most opinionated. The README says it carries "per-category capability matrices and definition-of-done checklists" across four categories: workflow-automation apps in the Zapier or n8n style, AI agent harness plugins, AI framework packages in the LangChain or LlamaIndex style, and direct application clients through `apify-client` or the REST API. A capability matrix is a reasonable thing to hand an agent here, because the four categories have genuinely different constraints and an agent that treats them as one task will produce something that fits none of them.

Installing apify-ultimate-scraper and running a first scrape

The README's quick start is a single command through the `skills` CLI. It names the repository URL and the skill explicitly, so you are installing one skill rather than the whole set:

npx skills add https://github.com/apify/agent-skills --skill apify-ultimate-scraper

After that, the agent is meant to accept a plain-language outcome rather than a tool call. The README gives this example prompt verbatim: "Scrape the top 50 results for 'AI coding tools' from Google Maps and save them to a CSV." The claim attached to it is that the skill handles "Actor selection, input shaping, run management, and result formatting".

Expect the agent to name an Actor before it runs anything. That is the point of the curated list: it should pick a Google Maps Actor from the 130+ the skill knows about instead of searching the store blindly. If your agent jumps straight to writing its own HTTP requests, the skill has not loaded.

For Claude Code specifically, the README's installation section points at a plugin flow, with the truncated line `/plugin m` in the README. Treat the README's per-client installation section as the authority for your client rather than assuming the `npx skills add` form applies everywhere. The README also documents a `commands/` pack called `apify-actor-commands` that adds slash commands such as `/create-actor` for guided scaffolding, which is a separate install from the scraper skill.

Where these skills are the wrong tool

Every skill in the repository assumes you are working against the Apify platform. There is no path here for someone who wants a self-contained scraper with no account, no Actor marketplace and no run management. If that is your requirement, the repository has nothing for you, and the fallback behaviour that makes `apify-ultimate-scraper` useful (searching the full store when a curated Actor is missing) is exactly the dependency you are trying to avoid.

The second limit is documentation depth. The README lists what each skill covers but does not document failure modes, rate limits, or what happens when an Actor run fails partway through a chained workflow. The use-case table implies chaining, for example the lead-generation prompt asks the agent to scrape Google Maps, then crawl the resulting websites for socials and owner emails, then export a ranked CSV. Nothing in the README describes how a failure in the second step is surfaced. For a single scrape that is fine. For a pipeline feeding a CRM, the error handling is the part you would want documented and it is not.

Third, the repository has no releases and no licence file visible in the top-level listing beyond the README's Apache 2.0 badge. The badge links to `LICENSE`, and the top-level entry list does not show that file, so the licence claim rests on the badge alone. That is usually fine and occasionally is not.

How this differs from a general-purpose agent skill collection

The obvious comparison is a general skill collection such as Addy Osmani's agent-skills, which is what a lot of the surrounding search traffic is about. The difference is scope, and it is not a small one. A general collection tends to hold process skills: how to write a commit, how to review a diff, how to structure a test. They are domain-agnostic by design and they work with whatever tools you already have.

apify/agent-skills is the opposite. Its value is entirely in platform-specific knowledge: which Actor handles Google Maps, what `actor.json` should contain, how standby mode works, how to shape input for a run. An agent given a general skill collection will still not know that 130+ curated Actors exist or which one to pick. An agent given these skills will know nothing extra about your codebase conventions.

The two are complementary rather than competing, and the repository says as much by pointing elsewhere for domain coverage: the README directs readers looking for "community-built, domain-specific skills (lead generation, brand monitoring, competitor intel, and more)" to a separate repository, `apify/awesome-skills`. That split is deliberate. This repository holds the platform primitives; the other holds the applications built on them.

Maintenance, licence and what an upgrade costs

The last push to the default branch was on 2026-09-09, and the repository is not archived. There are no published releases, so there is no version number to pin and no changelog to read before updating. Upgrades therefore arrive as commits to `main`, and the `npx skills add` command has no version argument in the README's example. If you need reproducibility across a team, that is a gap you will have to close yourself, for example by vendoring the skill directory at a known commit.

The practical upgrade cost is low in one direction and non-zero in the other. The skills are instruction files, so pulling a newer copy does not break a build. But the agent's behaviour can shift when a skill's instructions change, and without releases you will not get a signal that it happened. Anyone running these in an automated pipeline should diff the skill directory after an update rather than assume the behaviour is unchanged.

On licensing, the README carries an Apache 2.0 badge linking to a `LICENSE` file that does not appear in the top-level repository listing. Apache 2.0 would permit commercial use and modification with attribution and a notice of changes, but the badge is the only evidence available. Confirm the file exists before you rely on the terms; this is not legal advice.

Editorial conclusion

Adopt it if your agent already works against the Apify platform and you want it to choose Actors and shape inputs without you writing the plumbing each time. Skip it if you have no Apify account or never touch the store, because every skill here assumes that platform. Before installing, confirm which client you are running (the README's per-client installation section is the authority), then run the quick-start command and check that the agent can name an Actor for a request you already know the answer to.

Frequently asked questions

Official sources

1. apify/agent-skills on GitHub
2. Issues
3. Project website
4. README