Apify Pricing: Reconcile Actor Charges and Platform Usage
Added observed Website Content Crawler runs on 30 owned synthetic pages to demonstrate cost per accepted output. The dated observation CSV preserves full-precision inputs. The seven offline ledgers remain synthetic, and their pricing snapshot remains dated October 2.
Apify's monthly Starter plan is $19 with $19 of prepaid usage. That does not mean every Actor costs $19, or that its event price always has compute and proxy charges added on top. The chosen Actor's charging model determines which line items consume that allowance.
This guide starts with the current prices, then provides an offline charge-reconciliation worksheet. It helps you add known charges once and expose missing inputs. All seven example ledgers are synthetic: their Actor IDs, versions, consumption and accepted-record counts are invented test inputs. A separate worked example uses observed Actor runs on owned synthetic pages. Neither set is a customer invoice. ScrapingAnt publishes this article and sells a competing retrieval API.
Current Apify monthly prices
Checked October 2, 2026, in USD against Apify's official pricing. These are monthly plans; annual billing, custom contracts and partial cycles are outside the worksheet.
| Plan | Monthly fee | Prepaid usage | Compute price per CU |
|---|---|---|---|
| Free | $0 | $5 | $0.20 |
| Starter | $19 | $19 | $0.20 |
| Scale | $199 | $199 | $0.16 |
| Business | $999 | $999 | $0.13 |
Prepaid usage pays eligible charges within the account. Paid usage above the allowance goes on the next invoice; ordinary unused usage expires. Free access stops when its allowance is exhausted until the next cycle. A paid plan's fee remains due when usage is below its allowance. Source: prepaid usage and exhaustion FAQs.
A larger allowance alone does not establish the best plan. Check required resource limits and the chosen Actor's effective prices before buying. Actor owners decide whether to participate in Store discounts; the worksheet requires the actual event rate rather than applying a universal discount. Source: Store discounts.
Identify what the Actor price includes
Apify documents three relevant cases. Sources: Store pricing models and passing platform usage to users.
| Charging model | Developer event charges | Actor-run platform usage |
|---|---|---|
| Pay per event, usage included | Charged events × effective event price | Included; do not add it again |
| Pay per event, usage extra | Charged events × effective event price | Add billable resource usage |
| Usage-only | No additional developer event fee | Add billable resource usage |
Post-run dataset interactions remain billable in every model. Reading or writing data after the run and retaining storage can create separate usage. An included run price does not cover every future use of its output. Source: post-run storage costs.
What changed for rental Actors on October 1?
Apify published a rental sunset: new rental Actors and rental-price changes stopped on April 1, 2026; remaining rentals were scheduled to retire or migrate to usage-only on October 1, 2026. This is a published policy schedule, not our observation that every Actor migrated. The documentation and pricing page still contained rental references when checked on October 2. Confirm the selected Actor's actual model; the worksheet rejects rental input rather than guessing its replacement. Source: rental model sunset.
Build the bill of materials
Record the Actor ID, version or build, billing cycle, plan, dated official price source and charging model. Then collect charged event counts and resource totals for that cycle. Keep the Actor-run scope separate from post-run storage and access, and from unrelated account usage.
The official resource table supplies rates; it cannot tell you how much an arbitrary target will consume. Selected Free/Starter rates used by the examples are:
| Meter | Price | Required quantity |
|---|---|---|
| Compute | $0.20 per CU | Billed CU |
| Residential proxy | $8 per GB | Billed traffic GB |
| Dataset storage | $1 per 1,000 GB-hours | Integrated storage over time |
| Dataset reads | $0.0004 per 1,000 operations | Read operations |
| Dataset writes | $0.005 per 1,000 operations | Write operations |
| Request queue writes | $0.01 per 1,000 operations | Write operations |
| Internal transfer | $0.05 per GB | Billed internal GB |
| External transfer | $0.20 per GB | Billed external GB |
The worksheet also retains verified rates for key-value storage, queue storage/reads, SERPs and Website Unblocker. It preserves the published divisors: a price per 1,000 operations is not a price per operation. Datacenter IP offers are documented separately but not automatically priced; their applicable cadence, add-on amounts and allowance treatment must be known or listed as unresolved.
One CU corresponds to an hour with 1,024 MB allocated in Apify's compute-unit explanation. URL count and allocated memory do not establish billed consumption without runtime and other meters. The worksheet accepts supplied units; it does not predict retries, browser duration, traffic or future retention.
For historical reconciliation, use effective-period prices and billing records. Apify says historical run dollar displays use current service prices and are informational. Recalculating old meters at today's rates is not proof of an old invoice. Source: usage billing elements.
Charged events are not accepted records
Use already charged event counts, not requested event counts or validated output counts. Apify's event API can charge fewer events than requested when a limit is reached. Event limits are per run, and resources can continue briefly while a run stops. Do not treat an event cap as a guaranteed total monthly bill cap. Source: spending limits and chargedCount.
The examples use the documented, configurable apify-actor-start default of $0.00005 per event. Its charged count depends on memory, and enabling it covers the first five seconds of compute. The examples supply charged counts and applicable billed CU directly; they do not derive starts or subtract that window again. No real Actor is assumed to use this default. Source: start event.
Apply the account allowance once
Let W be eligible charges for the selected Actors, O other eligible account usage, A the prepaid allowance, F the subscription fee, and X known cash charges outside prepaid eligibility.
eligible account usage = W + O
prepaid applied = min(W + O, A)
paid-plan overage = max(W + O - A, 0)
modeled cycle cash cost = F + overage + X
This attributes a plan fee and usage overage to a cycle. Because overage is added to the next invoice, it is not a prediction of one invoice's payment amount. It excludes unknown adjustments, taxes, credits and unsupported billing arrangements. Do not add the prepaid allowance as a second charge or give each Actor its own account allowance.
Documented-rule flow, checked October 2, 2026. Unknown billable inputs stop an exact total; exceeding Free's allowance is infeasible in this model. Open the flow at full size.
Reproduce the synthetic ledgers
Use the versioned offline worksheet. With Git installed, clone and check out the tested commit:
git clone https://github.com/ScrapingAnt/scrapingant-examples.git
cd scrapingant-examples
git checkout fa9f7d878660eba9e3a053dd3fc6a780b7cb3412
cd examples/apify-pricing
./run.sh
python3 model.py fixtures/s2-event-plus-usage.json --csv /tmp/apify-s2-lines.csv
python3 model.py fixtures/s4-missing-usage.json --csv /tmp/apify-s4-lines.csv
Python 3.10.2 and 3.12.11 were tested. No API key or dependency installation is needed. ./run.sh runs 38 tests, compares 15 JSON/CSV files for seven scenarios, and checks three deterministic SVGs. The two model.py commands print JSON and export line-item CSVs. They do not run an Actor.
The fully specified synthetic Actor scopes below have a run-resource valuation of $21.64 and post-run charges of $0.584. S4 omits residential proxy quantity, so its complete run valuation is unknown. Event cases add 960 charged start events × $0.00005 = $0.048. The fixtures and captured outputs expose each meter. These are supplied quantities, not measured resource consumption.
| Synthetic case | Eligible workload charges | Modeled account cycle cash | What it tests |
|---|---|---|---|
| S1: events include run usage | $0.632 | $19 | Exclude the $21.64 run valuation; retain the plan floor |
| S2: events plus run usage | $22.272 | $22.272 | Add run usage once; $3.272 next-invoice overage |
| S3: usage-only | $22.224 | $22.224 | No developer event charge |
| S4: missing residential volume | Known subtotal $14.272 | Unknown | Unknown is not zero |
| S5: zero accepted records | $22.272 | $22.272 | Unit cost is undefined |
| S6: two Actors, plus $15 other usage | $44.544 | $59.544 | Apply one shared allowance; $40.544 overage |
| S7: S2 workload on Free | $22.272 requested | Infeasible | $17.272 beyond allowance; no invented paid overage |
Synthetic arithmetic, not customer bills. Underusing prepaid usage does not refund the subscription; extra usage above it creates overage. Open the chart at full size.
The model retains subcent amounts. It displays cents only at the end using half-up rounding, so S2 displays $22.27 while retaining $22.272 internally. This is a worksheet convention; Apify's actual invoice-rounding rules were not verified.
Use your own inputs and inspect unknowns
Copy fixtures/worksheet-template.json, set input_type to user_supplied, name the worksheet and enter only known values. The README defines every scope and unit. Use decimal strings or integer counts. Wrong units/currency/cadence, duplicate keys/scopes, fractional operation counts and invalid numbers are rejected.
Supply other_account_usage_usd excluding these Actor scopes. Do not enter the entire account total there and repeat the Actors. Supply outside-allowance charges separately. The code cannot detect the same actual usage entered into multiple scopes; reconcile their provenance yourself.
After filling your copied template, run python3 model.py worksheet.json --csv /tmp/apify-worksheet-lines.csv. The default rates.json snapshot is dated October 2, 2026. For a different effective period, supply an independently verified monthly snapshot with --rates your-rates.json; the model does not retrieve historical prices.
Keep unknown quantities as JSON null. CSV blanks also mean unknown. status=partial suppresses the precise account total and lists unresolved; missing included-run quantities appear as memo gaps. S4's known $19 cash lower bound assumes nonnegative charges and no adjustments; it is not a reconciled bill. A successful process exit alone does not mean the worksheet is complete. Invalid input exits with code 2.
unresolved_items records add-ons, eligibility, adjustments and limit feasibility that have not been settled. An empty list is your completeness attestation. Dated official URL metadata documents provenance but does not authenticate a supplied rate. Confirm the Actor's effective inclusion setting and price yourself.
Choose the accepted-output denominator
Define what a valid record requires: for example, a unique product ID, required fields and the expected revision. Keep charged failed attempts in the numerator; count an accepted record once. The examples' acceptance counts are synthetic assumptions.
workload usage per accepted record = W / accepted records
account cash per accepted record = (F + overage + X) / accepted records
S2 assumes 80 accepted records: both ratios are $0.2784 here. S1 uses the same assumed count: workload usage per record is $0.0079, while full account cash per record is $0.2375. They answer different questions. Full account cash includes the subscription and unrelated usage/add-ons; it is not marginal workload cost. Zero or unknown accepted count makes either ratio undefined.
The output also separates incremental workload cash, assuming you retain the same plan and other usage without this workload. None of these ratios establishes a real acceptance rate, price per URL or cheapest vendor.
Observed example: cost per accepted page
An inexpensive run can still yield expensive usable output. On October 7, 2026, we ran Website Content Crawler build 0.3.97 on the same 30 owned synthetic pages under three configurations. These are observed runs, separate from the invented worksheet ledgers above. Each configuration has one run; the observations do not establish a typical success rate or future price.
We kept the fixture bodies, assignments and original acceptance rule fixed. An accepted output had to correspond to one assigned URL, retain at least 95% of its 20 required sentence IDs and complete whitespace-normalized sentences, contain at most one distinct boilerplate ID, and come from a natively SUCCEEDED run. Missing, duplicate and erroneous output was not accepted. The primary score used text; Markdown and formatting markers were diagnostic. See the pinned fixtures and acceptance implementation.
The runs used playwright:firefox, 8,192 MB allocated memory, a 120-second run timeout, maximum concurrency 1 and zero request retries. The original transformer was readableTextIfPossible. The second run added only ignoreCanonicalUrl=true; the third retained that setting and changed only htmlTransformer to readableText. Apify documents that the ignore option skips both ETag and canonical-URL checks; it should not be enabled indiscriminately. Source: WCC input settings.
| Configuration | Assigned pages | Raw output rows | Accepted outputs | Informational run USD | USD per 1,000 accepted outputs in this batch |
|---|---|---|---|---|---|
| Original input | 30 | 3 | 2 | $0.02385345 | $11.926727 |
| Ignore ETag/canonical checks | 30 | 30 | 20 | $0.04011095 | $2.005547 |
Above, plus readableText | 30 | 30 | 30 | $0.02807915 | $0.935972 |
The numerator is each run's informational usageTotalUsd snapshot from October 7, including work that did not produce accepted output. It is not a reconciled cash payment. The ratios use full-precision amounts in the downloadable CSV; the table rounds run amounts to eight decimals and ratios to six. The CSV contains aggregate observations for reproducing this arithmetic; it does not independently verify an invoice or reproduce the historical runs. Multiplying by 1,000 makes the batch ratio easier to compare; we did not run 1,000 pages in these cells, and this is not a volume quote.
batch USD per 1,000 accepted outputs = informational run USD × 1,000 / accepted outputs
To reproduce the arithmetic without an API call, download the CSV and run this with Python 3:
python3 - observed-output-costs-2026-10-07.csv <<'PY'
import csv, sys
from decimal import Decimal
with open(sys.argv[1], newline="", encoding="utf-8") as source:
for row in csv.DictReader(source):
ratio = Decimal(row["informational_run_usd"]) * 1000 / int(row["accepted_outputs"])
print(row["stage"], format(ratio, ".6f"))
PY
Captured arithmetic output:
original 11.926727
ignore_etag_canonical 2.005547
readable_text 0.935972
The original run skipped 27 pages because different fixture bodies shared an observed ETag: a hosting confound, not evidence that WCC generally drops distinct pages. Ignoring those checks removed the skips. Ten remaining outputs retained all 20 required sentences but contained eight boilerplate IDs; changing the transformer reduced those IDs to zero. The final native log still reported 29 finished requests and one failed request, despite 30 accepted exported outputs. Export quality and error-free execution are separate checks.
These figures exclude allocation of the subscription fee, prepaid allowance, overage and later storage or data access. Historical dollar displays can change with current service prices, so a later snapshot of the same run must not be added as another charge. Account usage overlaps run usage; it is not an extra line item. Source: informational usage billing elements.
Use this example to choose the denominator for your own ledger: count outputs that satisfy your task, keep the costs of failed or unusable work, and reconcile account charges separately. It does not establish the cheapest Actor, general runtime reliability or comparative ScrapingAnt savings.
When the Apify platform is worth keeping
Keep Apify when your chosen Actor's extraction logic and hosted run/storage workflow meet requirements you would otherwise have to build. Reconcile the cost of that workflow before comparing it with a retrieval request. Apify's Actor running documentation describes the hosted execution model; its dataset documentation describes output storage.
If your application already owns orchestration and validation and needs page retrieval, a separate retrieval API may be worth evaluating. ScrapingAnt supports fetching without a headless browser with browser=false for static content; see its request format and browser modes. ScrapingAnt does not support localStorage operations; keep browser automation when setting, exporting or restoring that state is required.
For a compatible retrieval task, review current ScrapingAnt pricing and create an account if you want to evaluate it. This worksheet provides no evidence of comparative savings or a compatible replacement for a particular Actor.
Evidence and authorship: Official pricing sources and offline worksheet examples were checked/tested on October 2, 2026. The controlled WCC runs and informational charge snapshots above are dated October 7, 2026. AI agents assisted with the worksheet, synthetic fixtures, observations, visuals and drafting; separate AI agents performed calculation and editorial/factual review of the original worksheet article. ScrapingAnt is the publisher and Oleg Kulyk is the publication owner. No separate human review, actual invoice reconciliation or general runtime benchmark is claimed. Recheck official prices and the selected Actor's charging model before using the worksheet for a new period.