Apify is a library of ready-made scrapers. When the data sits on a page and no vendor offers it, your agent picks the right scraper, runs it, and gets structured rows back. Everyone who engaged with a LinkedIn post is the common one.
Apify starts a list from somewhere unusual. What it returns goes through enrichment like any other list.
things you can ask for
- “Pull everyone who engaged with this LinkedIn post url, then enrich them through Prospeo”
- “Scrape the team page on this company's site and match the names against Apollo”
- “Get the attendee list off this event page url and build a longlist”
- “Score the scraped rows with Hyreflow Agent and push the qualified ones into Atlas”
works well with Apify
- Prospeo
turn scraped names into contactable people
- Hyreflow Agent
score hundreds of scraped rows against the brief
- Firecrawl
a lighter option when you only need the page text
- Apollo
resolve a scraped name to a full profile
Ask for the outcome and your agent composes the run itself. Or start from a skill, a whole pipeline it already knows end to end.
browse all skills →What your agent reads before it touches Apify
Every tool ships with a written playbook, and the agent loads it before the first call. Auth, rate limits, what each call costs, which actions need your approval, and the mistakes worth avoiding. It is the difference between an agent that knows the tool and one that guesses at it.
Read the Apify docs →Show the raw playbookwritten for the agent
HOW in lib/apify.py. Docs: docs.apify.com (OpenAPI). Actor model — discover → run → read dataset.
Auth & config
- BYOK-only — Apify isn't resold on managed credits. Each workspace connects its own Apify token in Integrations; without one every Apify call returns
no_key. Hyreflow charges 0 credits; Apify bills you directly. - Base URL:
https://api.apify.com/v2· Auth:Authorization: Bearer <token>(envAPIFY_API_KEY; never hardcode). actorIdisusername/name; the client converts it tousername~namefor paths.
Operations (the canonical flow)
list_store_actors(search=...)— find an actor when you don't know its id (pick high rating/usage; for LinkedIn posts prefersupreme_coder/linkedin-post).get_actor_input_schema(actor_id)— required/optional inputs before running.run_actor_sync(actor_id, run_input)— run + return dataset items in one call (default).- Async:
run_actor(...)→get_run(run_id)(pollstatus+defaultDatasetId) →get_dataset_items(dataset_id).
Guardrails
- Actor runs cost compute on your own Apify account and some are rental-priced — pilot small (low
maxItems) before scaling. Read-only sourcing tool (no outreach side-effects). - Sites requiring login: prefer a vetted actor; avoid scraping behind auth without permission.
Handoff
Sourcing/scraping layer: e.g. scrape LinkedIn posts/engagers or profiles → structured rows → enrichment (emails/phones) → ATS/sequencer.
Field notes (production experience)
Field-shape note: these are vendor-native operational notes. The client returns the raw vendor JSON and uses the method names in this file — read field shapes accordingly (no normalized-wrapper /
result.data.prefix).
- Find the actor first: if you don't know the actor ID, search the store; the #1 result by quality is usually the right pick (ranked by rating x review count x runs x 30-day success). Prefer vetted, high-usage,
successRate30d >= 95%actors. For LinkedIn posts ->supreme_coder/linkedin-post; for post reactions/engagers ->harvestapi/linkedin-post-reactions. actorId=username/name(note: our adapter also accepts theusername~nameform per Apify's API).- Inspect the input schema before running - required/optional fields vary per actor and the wrapper fields can differ from the actor-page docs.
- Default to a sync run for one-call results; use async + poll only for long/non-blocking jobs.
- Validate payload with a tiny run (low
maxItems) before scaling.
Callable surface — lib/apify.py
Import: from lib.apify import Apify → instantiate Apify() (reads key from env). Base: https://api.apify.com/v2. Generic passthrough: request(method, path, *, params, json).
get_actor_input_schema(actor_id: str) -> Any— GET /acts/{actor}/input-schema — inspect required/optional input fields before running.get_dataset_items(dataset_id: str, *, limit: int | None = None, offset: int | None = None, **params) -> Any— GET /datasets/{datasetId}/items — fetch an actor run's output.get_run(run_id: str) -> Any— GET /actor-runs/{runId} — run status (look at data.status + data.defaultDatasetId).list_store_actors(*, search: str | None = None, limit: int = 25, **params) -> Any— GET /store — search the Apify actor store. Use first when you don't know the actorId.run_actor(actor_id: str, run_input: dict, **params) -> Any— POST /acts/{actor}/runs — start an async run. Poll get_run, then get_dataset_items.run_actor_sync(actor_id: str, run_input: dict, **params) -> Any— POST /acts/{actor}/run-sync-get-dataset-items — run an actor and return dataset items