Actor Pipeline Runner (Chain Actors in One Run)

Scrape, then clean, then filter, then push to your database. Four Actors, four separate runs, and four places to wire the output of one into the input of the next. Every time.

This Actor does the wiring. Give it a list of Actors in order, and it runs them one after another, handing each step the dataset the step before it produced. One call, one run, one set of results telling you what every step did.

What it does

• Runs a chain of Actors in order, up to 25 steps, each with its own input.
• Passes the data along automatically. Step 2 gets step 1's output dataset, step 3 gets step 2's, and so on. You do not paste a dataset ID anywhere.
• Knows which field to put it in. Most Actors call it datasetId, but not all of them do, so the common ones are built in and any Actor at all can be handled with a one-line datasetField override.
• Stops when something breaks. By default a step that does not succeed halts the chain, so a broken step never feeds bad data into the next one. Turn that off to push on regardless.
• Reports every step: which Actor ran, its status, its run ID and a link to it, the dataset it wrote, and how many rows that dataset held.
• Dry run first. Validate the whole chain and see the exact input each step would be started with, before anything runs or costs anything.

Example

{
  "steps": [
    {
      "actor": "apify/website-content-crawler",
      "label": "Crawl the docs site",
      "input": { "startUrls": [{ "url": "https://example.com/docs" }] }
    },
    {
      "actor": "nerolabs/dataset-filter-transform",
      "label": "Keep pages with real content",
      "input": { "filters": [{ "field": "text", "operator": "lengthGreaterThan", "value": 500 }] }
    },
    {
      "actor": "nerolabs/dataset-to-database",
      "label": "Push into Postgres",
      "input": { "connectionString": "postgres://...", "tableName": "docs", "writeMode": "upsert", "keyFields": ["url"] }
    }
  ]
}

The crawler runs, its dataset goes into the filter as datasetId, the filter's output dataset goes into the database push, and you get back:

#	Step	Status	Rows out	Dataset
0	Crawl the docs site	SUCCEEDED	214	aBc...
1	Keep pages with real content	SUCCEEDED	186	dEf...
2	Push into Postgres	SUCCEEDED	1	gHi...

Schedule that once and the whole chain runs itself.

What it is good for

• A nightly scrape-clean-load pipeline, on one schedule instead of four chained integrations.
• Giving an AI agent a single call that performs a multi-step data job, rather than a loop it has to write, wait on, and get right.
• Reusing the same cleaning and filtering steps behind several different scrapers.
• Trying a chain out with a dry run before committing to it.

Pricing, and the part people get wrong

Pay per event, no subscription.

Event	Price
Pipeline run	$0.05, once per pipeline
Pipeline step	$0.01 per step that actually started
Actor start	$0.00005 per run

Store discounts apply automatically: Bronze 10% off, Silver 20% off, Gold 30% off every event.

The important part: each step's own Actor charges you its own usual price, separately. This Actor charges for the orchestration only. A five-step pipeline costs $0.10 here, plus whatever those five Actors would have cost you if you had run them yourself, which is exactly what you would have paid anyway. Running them by hand is not cheaper, it is just more work.

What is not charged. A dry run costs nothing but the run start. A step that could not be started at all, for example because the Actor name is wrong, costs nothing. Steps that never started because an earlier one failed cost nothing.

A step that started and then failed is charged, because it really ran and its outcome, including the error, is a real answer.

How the data gets from one step to the next

Every step is started with its own input, plus one extra field holding the previous step's dataset ID. Which field that is depends on the Actor:

Actor	Field it receives the dataset in
Most Actors	datasetId
Dataset Cleaner & Exporter	sourceDatasetId
Dataset Diff & Change Detector	newDatasetId
Dataset Join & Merge	leftDatasetId
Anything else	set datasetField on that step

If a step should run purely on its own input and ignore what came before it, set skipDatasetInjection to true on that step.

To start the chain from data you already have, set Starting dataset and it is handed to the first step the same way.

Notes worth knowing

• Start with Dry run on. It checks every step, shows the exact input each would receive, and costs nothing. It is the default.
• Set the run timeout above the sum of the steps. This Actor waits for each step in turn, so its own run has to outlast all of them added together. The default is two hours.
• A step that writes no dataset breaks the chain quietly. If a step succeeds but produces no rows, the next step is told so in the warnings and runs on its own input.
• This Actor uses limited permissions, which means it can run other limited-permission Actors and read their results, and nothing else on your account. Most Store Actors qualify. An Actor that requires full permissions cannot be run as a step.

FAQ

Can I use it with Actors that are not Nero Labs Actors? Yes. Any Actor on the Store, and your own private ones. The only built-in knowledge is which input field receives the dataset, and datasetField covers everything not on the list above.

What if a step needs the output of two earlier steps? Give that step the second dataset explicitly in its own input, and let the pipeline inject the other one. For example, a Join step receives the previous step's dataset as leftDatasetId automatically while you set rightDatasetId yourself.

Does it run steps in parallel? No, and deliberately. Each step's input depends on the step before it finishing, so the chain is sequential by design.

What happens if a step takes too long? Each step has a maximum wait, one hour by default, and a step can set its own. If the wait runs out, that step is reported as not having succeeded, and the usual stop-on-failure rule applies.

Can I see what a step actually produced? Yes. Every step row carries its dataset ID and a link to its own run, so you can open any intermediate result, not just the final one.

If this saved you wiring a chain of Actors together by hand, a review on the Store page genuinely helps.

The toolkit this was built for

• Dataset Cleaner & Exporter: dedupe (exact, normalized or fuzzy), flatten nested JSON, clean emails, phones and URLs, then export CSV or Excel.
• Dataset Filter & Transform: keep the rows you want and reshape the fields (dates, replace, split, hash, 25 ops), sort, dedupe, limit.
• Dataset Join & Merge: VLOOKUP-style joins and unions across two datasets, files or Google Sheets on a key field.
• Dataset Aggregate, Group By & Pivot: counts, sums, averages and pivot tables per group.
• Dataset Diff & Change Detector: what was added, removed or changed since last time.
• Dataset AI Enrich: add LLM-generated columns (classify, extract, summarise) to every row, no API key needed.
• Dataset Charts & Report: chart images (PNG, SVG) and a PDF or HTML report from any data.
• Dataset to Postgres, Supabase & MySQL: write the rows straight into a database table, creating it if needed.
• Dataset to REST API: send every row to any API as its own request, with templating and auth presets.
• Actor Pipeline Runner (this one): chain several of these together in one run, each step fed the previous step's dataset.

A common pipeline: a scraper, then Cleaner, then Filter & Transform, then Join to enrich from a sheet, then Aggregate for the weekly summary, with Diff watching what changed and Charts & Report turning the numbers into the Monday PDF. Pipeline Runner runs that whole chain in one call.

For AI agents

Pay per event, agent-payable through x402 and MCP, limited permissions, no standby. Input: steps, an ordered array of {actor, input, datasetField?, skipDatasetInjection?, label?, waitSecs?, memoryMbytes?, build?}; optional initialDatasetId to seed the first step; stopOnFailure (default true); dryRun to validate the chain and get each step's resolved input back without running anything. Each step is started with the previous step's default dataset ID injected into its dataset input field. Returns one dataset item per step with status, runId, runUrl, datasetId, itemCount and error, plus a PIPELINE_SUMMARY key-value record carrying finalDatasetId. Charged $0.05 per pipeline plus $0.01 per started step; each step's own Actor bills its own events to the caller separately.