Cost Calculator

Apify actor cost calculator tells you exactly what any actor will cost at any volume before you commit a single credit. Provide a target actor ID, set your estimated monthly runs, and the actor returns a complete cost breakdown: PPE price per event, average compute cost per run, and projected totals at 1x through 100x your baseline volume. Planning a batch of 500 runs or evaluating a new actor for production? Know the number first.

The calculator reads pricing metadata and run history directly from the Apify API — it never triggers a run on the target actor. Analysis completes in seconds, costs $0.20 per calculation, and produces a structured JSON report you can pipe into a spreadsheet, a Slack alert, or a cost monitoring dashboard. Use it once before adopting a new actor, or schedule it weekly to track cost drift across your entire portfolio.

What data can you extract?

Why use the Apify actor cost calculator?

Most Apify users discover what an actor costs by running it — and getting surprised by the invoice. A pay-per-event actor charging $0.15 per item feels cheap for 10 items in a test run. At 2,000 items per day, that is $300 a day. The math is not hard; it is just easy to skip when you are moving fast.

This actor makes the math automatic. It fetches the actor's current pricing configuration and analyzes up to 20 recent succeeded runs to calculate real average costs — not theoretical estimates from marketing copy. You get a 6-tier projection table in a single API call, no spreadsheet required.

• Scheduling — run weekly against your actor portfolio to catch pricing changes or cost drift before they hit your invoice
• API access — trigger from Python, JavaScript, or any HTTP client and pipe results into your existing cost tracking system
• Proxy rotation — not required for this actor; it reads from the Apify API directly with no scraping involved
• Monitoring — configure Apify webhooks to alert you when projected monthly spend crosses a threshold
• Integrations — push results to Google Sheets, HubSpot, Zapier, or any downstream system that accepts JSON

Features

• Live PPE pricing extraction — reads the latest pricingInfos entry from the actor's API record, extracting event name, price per event in USD, and the human-readable event title
• Real run history analysis — fetches the last 20 runs descending by start time, filters to SUCCEEDED status only, and averages duration, memory, total platform cost, and charged event count
• Six-tier volume projection table — computes estimatedRuns × [1, 2, 5, 10, 50, 100] and for each tier returns separate compute cost, PPE cost, and combined total — all rounded to the nearest cent
• Compute and PPE cost separation — reports avgComputeCost (platform CU charge) and avgPpeCharge (PPE event charge) independently so you can see which cost driver dominates
• Zero side effects — the actor calls only GET /v2/acts/{id} and GET /v2/acts/{id}/runs; it never triggers a run on the target actor, incurs no actor-on-actor usage, and does not modify any data
• Actor ID normalization — accepts both the username/actor-name slug format and raw Apify actor IDs; internally converts / to ~ for correct REST API routing
• Graceful degradation — if the target actor has no PPE pricing, PPE fields return $0 and none; if there are no recent runs, compute averages return $0 with a note; the report is always returned
• 30-second API timeouts — both API calls use AbortSignal.timeout(30000) to prevent hung runs
• Lightweight footprint — runs in 128 MB minimum memory with no browser or proxy dependencies, completing in under 10 seconds for most actors

Use cases for Apify actor cost calculator

Pre-adoption cost vetting

Before building a production workflow around a new actor, a developer or data engineer uses the cost calculator to project monthly spend at realistic volumes. Knowing that a scraper costs $0.18 per run at 500 MB and charges $0.005 per result, and that recent runs average 40 results, puts the monthly cost for 3,000 runs at roughly $756 — a number that belongs in the architecture discussion before the first line of integration code is written.

Monthly portfolio cost review

An Apify developer running 15-30 actors runs the cost calculator across their entire portfolio each month to catch pricing drift. An actor's PPE rate can change when a developer pushes a new version. By comparing the current projection against last month's, any unexpected rate changes surface immediately — before they appear on an invoice.

Budget planning and Apify plan selection

A team deciding between the Apify Starter, Scale, and Business subscription plans needs realistic spend projections to choose correctly. The cost calculator produces volume-scaled estimates for each actor in a planned workflow. Feed those estimates into the Plan Advisor to get a subscription recommendation based on actual projected usage, not guesswork.

Agency client cost estimation

A scraping agency quoting a client data project uses the cost calculator to build an accurate cost model before committing to a fixed-price contract. Knowing the per-run cost for each actor in the pipeline — and projecting it at the client's required monthly volume — prevents the common agency mistake of underpricing jobs where actor costs exceed the quoted fee.

Cost optimization benchmarking

A developer refactoring an actor to reduce memory usage or decrease events per run uses the cost calculator before and after the change to quantify the savings. The before/after comparison of avgComputeCost and avgEventsPerRun makes the optimization impact concrete: a 25% reduction in average events per run translates directly to 25% lower PPE spend at any volume.

Automated cost alerting

An ops team integrates the cost calculator into a scheduled Apify workflow. Each week it runs the calculator against a list of production actors and compares projections against a budget threshold. If the projected monthly cost for any actor exceeds the threshold, a webhook fires a Slack alert. The cost of the monitoring run ($0.20 per actor) is negligible compared to the overspend it prevents.

How to estimate actor run costs

1. Find the target actor's ID — navigate to the actor on the Apify Store, copy the URL slug (e.g., ryanclinton/google-maps-email-extractor), or use the internal actor ID from the actor's console page.
2. Set your monthly run estimate — enter how many times you expect to run that actor per month. The default of 100 is a reasonable starting point; adjust it to match your actual planned volume. The actor will project costs at 1×, 2×, 5×, 10×, 50×, and 100× this number.
3. Run the actor — click "Start" and wait approximately 5-10 seconds. The actor reads two API endpoints and runs no external scraping.
4. Download the cost report — open the Dataset tab to view the JSON output, or export as CSV. Each record contains the full projection table alongside the per-run averages that produced it.

Input parameters

Input examples

Estimate costs for a specific actor at default volume:

{
  "targetActorId": "ryanclinton/google-maps-email-extractor"
}

Project costs at higher volume for budget planning:

{
  "targetActorId": "ryanclinton/website-contact-scraper",
  "estimatedRuns": 500
}

Analyze an actor using its internal Apify ID:

{
  "targetActorId": "s2FM5uFH9uFH9F2eZ4pZ9",
  "estimatedRuns": 50
}

Input tips

• Use the URL slug format — username/actor-name as it appears in the Apify Store URL is the most reliable input; raw actor IDs also work but are harder to find.
• Set estimatedRuns to your realistic monthly volume — the projection table multiplies this value by 1×, 2×, 5×, 10×, 50×, and 100×, so a realistic baseline makes all six tiers meaningful.
• Run once per actor, not per run — the calculator reads the last 20 runs from history; you do not need to re-run it every time you use the target actor, only when you want a fresh projection.
• If no runs exist yet — for brand-new actors with zero run history, the compute averages will return $0. Use the PPE price alone to estimate cost, then re-run the calculator after 5-10 production runs to get real averages.
• Batch portfolio reviews — if you need to analyze 10+ actors, trigger 10 parallel runs via the API; each takes under 10 seconds and costs $0.20, so a full 20-actor portfolio review costs $4.00.

Output example

{
  "actorName": "ryanclinton/google-maps-email-extractor",
  "actorId": "ryanclinton/google-maps-email-extractor",
  "ppePrice": 0.005,
  "ppeEvent": "result",
  "ppeTitle": "Result scraped",
  "avgComputeCost": 0.032,
  "avgPpeCharge": 0.15,
  "avgEventsPerRun": 30,
  "avgDuration": 45,
  "avgMemoryMb": 512,
  "recentRunsAnalyzed": 18,
  "projections": [
    { "runs": 100,   "computeCost": 3.20,  "ppeCost": 15.00,  "totalCost": 18.20  },
    { "runs": 200,   "computeCost": 6.40,  "ppeCost": 30.00,  "totalCost": 36.40  },
    { "runs": 500,   "computeCost": 16.00, "ppeCost": 75.00,  "totalCost": 91.00  },
    { "runs": 1000,  "computeCost": 32.00, "ppeCost": 150.00, "totalCost": 182.00 },
    { "runs": 5000,  "computeCost": 160.00,"ppeCost": 750.00, "totalCost": 910.00 },
    { "runs": 10000, "computeCost": 320.00,"ppeCost": 1500.00,"totalCost": 1820.00 }
  ],
  "calculatedAt": "2026-03-20T14:32:17.004Z"
}

Output fields

How much does it cost to estimate actor run costs?

The Apify actor cost calculator uses pay-per-event pricing — you pay $0.20 per calculation. Platform compute costs are included. The actor completes in under 10 seconds using minimal memory.

You can set a maximum spending limit per run to control costs. The actor stops when your budget is reached.

Apify's free tier includes $5 of monthly credits — enough for 25 cost calculations at no charge. For teams running weekly portfolio reviews across 20 actors, the monthly cost is $3.20.

Estimate actor run costs using the API

Python

from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run = client.actor("ryanclinton/actor-cost-calculator").call(run_input={
    "targetActorId": "ryanclinton/website-contact-scraper",
    "estimatedRuns": 500
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"Actor: {item['actorName']}")
    print(f"PPE: ${item['ppePrice']} per {item['ppeEvent']}")
    print(f"Avg compute/run: ${item['avgComputeCost']}")
    print(f"Avg PPE/run: ${item['avgPpeCharge']}")
    for projection in item.get("projections", []):
        print(f"  {projection['runs']} runs → ${projection['totalCost']}")

JavaScript

import { ApifyClient } from "apify-client";

const client = new ApifyClient({ token: "YOUR_API_TOKEN" });

const run = await client.actor("ryanclinton/actor-cost-calculator").call({
    targetActorId: "ryanclinton/website-contact-scraper",
    estimatedRuns: 500
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
for (const item of items) {
    console.log(`Actor: ${item.actorName}`);
    console.log(`PPE: $${item.ppePrice} per ${item.ppeEvent}`);
    console.log(`Avg compute/run: $${item.avgComputeCost}`);
    console.log(`Avg PPE/run: $${item.avgPpeCharge}`);
    for (const p of item.projections) {
        console.log(`  ${p.runs} runs → $${p.totalCost}`);
    }
}

cURL

# Start the actor run
curl -X POST "https://api.apify.com/v2/acts/ryanclinton~actor-cost-calculator/runs?token=YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "targetActorId": "ryanclinton/website-contact-scraper",
    "estimatedRuns": 500
  }'

# Fetch results (replace DATASET_ID with the defaultDatasetId from the run response)
curl "https://api.apify.com/v2/datasets/DATASET_ID/items?token=YOUR_API_TOKEN&format=json"

How the Apify actor cost calculator works

Phase 1: Actor pricing metadata fetch

The actor calls GET /v2/acts/{encodedId} where encodedId converts any / in the actor slug to ~ for REST API compatibility. From the response, it reads the last entry in the pricingInfos array — the current pricing configuration. Within that entry, it extracts the first key from pricingPerEvent.actorChargeEvents, which holds the event name, price per event in USD, and the event title. If no PPE pricing exists, these fields default to 0, "none", and "N/A" respectively.

Phase 2: Run history analysis

The actor calls GET /v2/acts/{encodedId}/runs?limit=20&desc=true to retrieve the 20 most recent runs ordered by start time descending. It filters this list to only SUCCEEDED runs — timed-out, failed, or aborted runs are excluded to avoid skewing cost averages. For each succeeded run, it reads stats.runTimeSecs for duration, options.memoryMbytes for memory (defaulting to 256 MB if absent), usageTotalUsd for total platform cost, and chargedEventCount for PPE events charged. It sums these across all succeeded runs and divides by runCount to produce per-run averages. The average PPE charge is then derived as ppePrice × avgEventsPerRun.

Phase 3: Volume projection calculation

The actor generates six projection tiers by applying multipliers [1, 2, 5, 10, 50, 100] to the estimatedRuns input. For each tier, it computes computeCost = avgComputeCost × runs and ppeCost = avgPpeCharge × runs, rounds both to the nearest cent, and sums them for totalCost. Both API calls use AbortSignal.timeout(30000) to prevent hung runs on slow API responses.

Phase 4: Output and PPE charge

The assembled report is pushed to the Apify dataset in a single Actor.pushData() call. The actor then charges the cost-calculation PPE event at $0.20. If the run's spending limit has been reached prior to this point, the charge is skipped with a warning log rather than throwing an error.

Tips for best results

1. Verify the actor ID format before running. The most common failure is an incorrect actor ID — username/actor-name must match the Apify Store URL exactly, including case. Copy the slug directly from the store URL to avoid typos.

2. Use at least 10 succeeded runs in history for reliable averages. The calculator needs run history to produce meaningful averages. For a brand-new actor with fewer than 5 runs, treat the compute average as a rough estimate and re-run after a week of production use.

3. Set estimatedRuns to your P50 volume, not your peak. The projection table already shows 10× and 100× your baseline. Setting the baseline to your worst-case volume distorts the lower tiers. Use your typical week's volume extrapolated to a month.

4. Run the calculator before and after changing an actor's pricing. If you develop actors and update PPE event prices, run the calculator on your own actor to see how the change affects projected costs at different volumes — the same way a customer would evaluate it.

5. Combine with Plan Advisor for subscription decisions. The cost calculator tells you what individual actors cost. The Plan Advisor takes those numbers and recommends the most cost-effective Apify subscription plan for your total monthly spend.

6. Schedule monthly portfolio reviews with the API. Trigger a cost calculator run for each of your production actors via the Apify API on a monthly schedule. Store the results in a dataset or push to a Google Sheet to build a cost trend report over time.

7. For actors with no PPE pricing, the ppePrice and avgPpeCharge will be $0. The useful data is in avgComputeCost and avgDuration, which reflect pure platform compute costs.

Combine with other Apify actors

Limitations

• Averages from up to 20 runs only. The calculator analyzes at most 20 recent succeeded runs. For actors with highly variable run costs (e.g., short test runs mixed with large production runs), the averages may not represent a typical production run. Consider using the API directly to inspect individual run costs if variance is high.
• PPE pricing reflects only the first event type. Some actors charge multiple PPE event types. The calculator extracts only the first event in actorChargeEvents. If the actor uses multiple event types with different prices, the projection will undercount total PPE costs.
• Cannot predict costs for actors you cannot access. The actor uses your APIFY_TOKEN from the Apify environment. If you do not have read access to the target actor (e.g., a private actor owned by another user), the API will return a 404 and the calculator will report an error.
• Projections assume consistent run behavior. Volume projections multiply average costs linearly. If an actor's cost per run changes at high concurrency (e.g., due to longer wait times or proxy costs), actual costs may differ from projections.
• New actors have no history. For actors with zero succeeded runs, avgComputeCost, avgEventsPerRun, and all projection values will be $0. The PPE price is still extracted from pricing metadata.
• Pricing metadata reflects the current version. If an actor developer changes PPE pricing after you run the calculator, your projections become stale. Re-run the calculator after any actor update.
• No retry logic on API failures. If either Apify API call returns a non-OK status or times out after 30 seconds, the actor logs the error and exits without retrying. Re-run manually if you see a transient API error.

Integrations

• Zapier — trigger a cost calculation run when a new actor is added to your Zapier workflow, then log the projection to a Google Sheet
• Make — build a monthly budget report scenario that runs the cost calculator across all your production actors and emails the results
• Google Sheets — push projection results to a tracking sheet to build month-over-month cost trend charts
• Apify API — integrate cost checks into your CI/CD pipeline so actor deployments automatically surface cost impact before going live
• Webhooks — fire a webhook when projections exceed a threshold to trigger budget alerts in Slack, PagerDuty, or email
• LangChain / LlamaIndex — feed actor cost data to an LLM agent that recommends cost optimization strategies across your Apify portfolio

Troubleshooting

• "Actor not found" error in output — The targetActorId does not match any accessible actor. Check that the slug matches the Apify Store URL exactly (e.g., ryanclinton/website-contact-scraper, not website-contact-scraper). If the actor is private or owned by another account, your token may not have read access.

• All projection costs showing $0 — This means the target actor has no run history (zero succeeded runs). PPE price will still be populated if the actor has PPE pricing configured. Re-run after the target actor has completed a few production runs to get meaningful averages.

• PPE price is $0 but the actor charges per event — The actor may use a non-standard pricingInfos structure, or the most recent pricing entry may not include pricingPerEvent. This can happen with actors that use legacy flat-rate pricing or custom billing arrangements. Check the actor's Store page for manual pricing information.

• Run times out — Both API calls have 30-second timeouts. If the Apify API is experiencing delays, the run may time out. Wait a few minutes and try again. If timeouts persist, check Apify status for ongoing incidents.

• Projections seem too high — Verify that estimatedRuns is set to your monthly volume, not your daily or annual volume. A value of 1000 means 1,000 runs per month as the baseline, with projections going up to 100,000 runs at the 100× tier.

Responsible use

• This actor only accesses actor metadata and run statistics via the Apify API using your own credentials.
• It reads only actor pricing information and run history for actors accessible to your Apify token.
• No external websites are scraped; all data comes from the Apify platform API.
• Do not use this actor to probe pricing information for private actors you do not have authorized access to.
• For guidance on Apify platform terms of service, see the Apify Terms of Service.

FAQ

How accurate are the actor cost projections? Projections are based on averages from up to 20 recent succeeded runs. If those runs are representative of your planned usage (similar input size, same concurrency), projections are accurate to within 10-20%. For actors with high run-to-run variance, check the individual run costs in the Apify console for a fuller picture.

How many runs can I analyze with the Apify actor cost calculator in one session? Each cost calculator run analyzes exactly one target actor. To analyze multiple actors, trigger multiple runs in parallel via the API — each costs $0.20 and completes in under 10 seconds, so a 20-actor portfolio review takes about 10 seconds and costs $4.00 total.

Does the cost calculator run the target actor? No. The calculator only calls two read-only Apify API endpoints: one to fetch actor metadata and one to fetch recent run history. The target actor is never triggered, no compute is consumed on it, and no credits are charged to it.

What does the cost calculator return if an actor has no PPE pricing? All PPE fields (ppePrice, ppeEvent, ppeTitle, avgPpeCharge) will reflect $0 or "none". The compute cost averages from run history are still calculated and returned. The projections will show compute costs only, with $0 in ppeCost.

Can I use the cost calculator on any actor in the Apify Store? You can analyze any actor that your Apify token has read access to. All public actors in the store are accessible. Private actors are only accessible if your token belongs to the owning account.

How is this different from checking the actor's pricing page manually? The actor's Store page shows the PPE price per event, but it does not show your average events per run or compute cost per run. The cost calculator combines pricing metadata with real run history to produce a complete cost model — the total cost per run and projected monthly cost at your actual volume — which the Store page does not provide.

Does the actor cost calculator work for actors that use flat-rate compute pricing instead of PPE? Yes. For non-PPE actors, PPE fields return $0, but the avgComputeCost from run history reflects the actual CU-based compute charge per run. The projections show compute costs only. This gives you a meaningful monthly cost estimate for any actor regardless of pricing model.

Can I schedule the cost calculator to run automatically every month? Yes. Use Apify's built-in scheduler or trigger runs via the API on a cron schedule. Each scheduled run produces a fresh projection based on the most recent 20 runs, so the estimates stay current as the target actor's behavior evolves.

How long does a typical cost calculator run take? Most runs complete in 3-8 seconds. The actor makes two sequential API calls, each with a 30-second timeout. Total elapsed time depends on Apify API response latency.

Is it legal to read another actor's run history via the Apify API? The actor uses your own credentials to access your own run history or publicly visible run metadata. It does not access private run data that belongs to other Apify users. Apify's API enforces token-based access controls, so you can only read what your token has permission to read.

What happens if I enter the wrong actor ID? The actor returns an error record with the message "Actor not found (404). Use the Apify actor ID or exact username/actorName." and exits cleanly. No PPE charge is applied if the actor ID is invalid and the run fails before the charge event.

How do I know which projection tier to use for my budget? Use your realistic monthly run volume as estimatedRuns. The projection at 1× is your expected monthly cost. The 2× and 5× tiers show your cost if usage doubles or quintuples. The 50× and 100× tiers are useful for stress-testing budgets before scaling a workflow.

Help us improve

If you encounter issues, you can help us debug faster by enabling run sharing in your Apify account:

1. Go to Account Settings > Privacy
2. Enable Share runs with public Actor creators

This lets us see your run details when something goes wrong, so we can fix issues faster. Your data is only visible to the actor developer, not publicly.

Support

Found a bug or have a feature request? Open an issue in the Issues tab on this actor's page. For custom solutions or enterprise integrations, reach out through the Apify platform.