Apify Pricing: Reconcile Actor Charges and Platform Usage
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. They are not invoices or observed Apify performance. 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.
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 Apify sources and offline examples were checked/tested on October 2, 2026. AI agents assisted with the worksheet, synthetic fixtures, visuals and drafting; separate AI agents performed calculation and editorial/factual review. ScrapingAnt is the publisher and Oleg Kulyk is the publication owner. No separate human review, actual invoice reconciliation or Apify runtime benchmark is claimed. Recheck official prices and the selected Actor's charging model before using the worksheet for a new period.