Plan Advisor

Plan Advisor analyzes your real Apify account usage and recommends the cheapest subscription plan that covers your workload. It reads your actor portfolio and the last 30 days of run history, calculates what you actually spend on compute, and models that spend against every available plan tier — so you stop guessing and start paying the right amount.

Built for Apify developers, agencies, and anyone managing an actor portfolio, this tool answers the question that the billing page never directly answers: "Am I on the right plan?" It takes 10 seconds to run, costs $0.25, and can save you $49–$450 per month if you are on the wrong tier.

What data does Plan Advisor produce?

Why use Plan Advisor?

Choosing the wrong Apify plan is a silent tax on your business. The Free plan's $5 monthly credit runs out fast if you have even a handful of regular actors. The Starter plan at $49 is often unnecessary if your compute spend is $8. And many developers on the Scale plan at $499 are running well under $100 of compute per month.

The Apify billing dashboard shows you what you have spent. It does not tell you what plan you should be on. That calculation — comparing your trailing 30-day compute against each plan's included credit allowance — requires pulling run data from the API, summing costs, and modeling overage for each tier. Plan Advisor does this automatically.

Beyond the recommendation, it also flags memory inefficiencies. If your actors are averaging 3,000 MB when they could run at 512 MB, that alone can cut your compute bill by 80%. The tips surface these patterns without requiring you to audit every actor manually.

• Scheduling — run monthly before your billing cycle resets to catch plan drift before it costs you
• API access — trigger from Python, JavaScript, or any HTTP client as part of a billing audit workflow
• No proxy required — this actor calls the Apify API directly; no external sites, no blocks
• Monitoring — combine with Cost Watchdog to get alerted when spending creeps toward the next tier
• Integrations — pipe results to Google Sheets or Slack to keep your team informed on account costs

Features

• 30-day rolling usage window — analyzes runs started within the last 30 days, matching the standard Apify billing cycle
• Portfolio-wide scan — iterates over your actor list and fetches up to 100 runs per actor, capped at 50 actors to avoid timeouts
• Compute cost aggregation — sums usageTotalUsd from each run's stats to build a true monthly compute figure, not an estimate
• Three-tier plan modeling — compares your spend against Free ($5 credits), Starter ($49 credits), and Scale ($499 credits) simultaneously
• Overage calculation — for plans where usage exceeds included credits, calculates the exact dollar overage rather than a percentage
• Cheapest-fit algorithm — filters plans where fits = true, sorts by monthly subscription cost, and returns the cheapest option
• Enterprise fallback — if your usage exceeds all three standard plans, the recommendation flags Scale-with-overage or Enterprise
• Memory efficiency flag — checks average memory consumption across all analyzed runs and flags it when it exceeds 2,048 MB
• High-volume flag — warns when run count exceeds 1,000 on the Free plan, where credit exhaustion mid-month is a real risk
• Low-usage flag — identifies when actual compute is under $10 so you know if the Free plan is viable
• Zero inputs required — uses your APIFY_TOKEN environment variable, which the Apify platform injects automatically into every run
• Pay-per-event pricing — charges a single plan-advice event at $0.25; no compute overage for the analysis itself

Use cases for Apify plan comparison

Monthly billing review

Finance teams and solo developers running actor portfolios benefit from a structured monthly review. Instead of scrolling through billing history and doing mental math, run Plan Advisor before your renewal date to confirm your current plan still fits or to catch when you have grown into the next tier.

New account setup

When setting up a new Apify account for a client or project, you often do not know yet what the compute spend will look like. After the first 30 days of real usage, Plan Advisor gives you a data-backed recommendation rather than a guess, so you can upgrade or downgrade with confidence.

Agency billing optimization

Agencies running Apify accounts for multiple clients frequently over-provision. Running Plan Advisor on each client account surfaces which ones are paying $49/month for $6 of compute — savings that can be passed on or pocketed.

Developer cost auditing

When a sudden spike in actor runs occurs, a developer needs to know whether the current plan still holds or whether overage charges are accumulating. Plan Advisor quantifies the exposure immediately without waiting for the monthly invoice.

Portfolio memory optimization

The memory tips section identifies when average memory allocation across your fleet is inflated. For accounts where actors default to 4,096 MB but only need 512 MB, this single flag can justify a full memory audit that reduces compute costs by 60–80%.

Pre-scale infrastructure planning

Before launching a new actor or scaling up run frequency, you want to know which plan tier the new workload will push you into. Run Plan Advisor after a test period to model the impact before committing to a higher subscription.

How to get your Apify plan recommendation

1. No input needed — navigate to the actor page and click "Start". The actor reads your API token automatically from the Apify platform environment. There is nothing to configure.
2. Wait for the analysis — the actor fetches your actor list and run history. For accounts with 50+ actors, this takes 30–60 seconds. You will see a "Analyzing actor portfolio..." status message while it runs.
3. Review the output — the Dataset tab shows your recommendation, the full plan comparison table, your current usage figures, and any optimization tips.
4. Download results — export as JSON or CSV from the Dataset tab. Share with your team or save for quarterly billing reviews.

Input parameters

No input parameters are required. Plan Advisor uses your APIFY_TOKEN environment variable, which the Apify platform injects automatically into every actor run. There is nothing to configure — just click "Start".

Input examples

Standard run (no input required):

{}

API-triggered run (empty input body):

{}

Scheduled monthly run:

{}

Input tips

• Just click Start — no form to fill in, no API keys to paste. The platform handles authentication.
• Schedule monthly runs — add a cron schedule of 0 0 1 * * (first of each month) to automate your billing review before the cycle resets.
• Run after new actors launch — whenever you publish a new actor and start running it regularly, trigger a fresh Plan Advisor run to see if your plan tier has shifted.

Output example

{
    "currentUsage": {
        "monthlyRuns": 340,
        "monthlyComputeUsd": 12.47,
        "totalActors": 52,
        "actorsAnalyzed": 50,
        "avgMemoryMb": 512
    },
    "planComparison": [
        {
            "plan": "Free",
            "monthlyCost": 0,
            "creditsIncluded": 5,
            "fits": false,
            "overage": 7.47,
            "totalCost": 7.47,
            "concurrency": 5,
            "retention": 7
        },
        {
            "plan": "Starter",
            "monthlyCost": 49,
            "creditsIncluded": 49,
            "fits": true,
            "overage": 0,
            "totalCost": 49,
            "concurrency": 25,
            "retention": 30
        },
        {
            "plan": "Scale",
            "monthlyCost": 499,
            "creditsIncluded": 499,
            "fits": true,
            "overage": 0,
            "totalCost": 499,
            "concurrency": 100,
            "retention": 90
        }
    ],
    "recommendation": "Starter",
    "reasoning": "Your monthly compute usage of $12.47 fits within Starter's $49 credit allowance.",
    "tips": [
        "Your usage is low enough for the Free plan"
    ],
    "advisedAt": "2026-03-20T10:14:22.000Z"
}

Output fields

How much does it cost to get an Apify plan recommendation?

Plan Advisor uses pay-per-event pricing — you pay $0.25 per analysis. Platform compute costs are included in that price.

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

For context: if Plan Advisor identifies that you are on the Starter plan ($49/month) but your compute is under $5, acting on that recommendation saves $528/year. The analysis pays for itself in the first second it detects a mismatch.

Get your Apify plan recommendation using the API

Python

from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run = client.actor("ryanclinton/actor-plan-advisor").call(run_input={})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"Recommendation: {item['recommendation']}")
    print(f"Monthly compute: ${item['currentUsage']['monthlyComputeUsd']}")
    print(f"Reasoning: {item['reasoning']}")
    for tip in item.get("tips", []):
        print(f"  Tip: {tip}")

JavaScript

import { ApifyClient } from "apify-client";

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

const run = await client.actor("ryanclinton/actor-plan-advisor").call({});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
for (const item of items) {
    console.log(`Recommendation: ${item.recommendation}`);
    console.log(`Monthly compute: $${item.currentUsage.monthlyComputeUsd}`);
    console.log(`Reasoning: ${item.reasoning}`);
    item.tips.forEach(tip => console.log(`  Tip: ${tip}`));
}

cURL

# Start the actor run
curl -X POST "https://api.apify.com/v2/acts/ryanclinton~actor-plan-advisor/runs?token=YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{}'

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

How Plan Advisor works

Phase 1 — Actor portfolio discovery

The actor calls GET /v2/acts?my=true&limit=500 using your APIFY_TOKEN. This returns your full actor list. For accounts with more than 50 actors, only the first 50 are analyzed for run history. The total actor count is still reported in currentUsage.totalActors, so you know the coverage ratio.

Phase 2 — Run history aggregation

For each actor (up to 50), the actor calls GET /v2/acts/{actorId}/runs?limit=100&desc=true. Runs are filtered to those with a startedAt timestamp within the last 30 days (rolling window, not calendar month). For each qualifying run, three fields are extracted: usageTotalUsd (compute cost), stats.runTimeSecs (duration), and options.memoryMbytes (memory allocation). These are accumulated across all actors and all runs into portfolio-wide totals.

Phase 3 — Plan modeling

The aggregated monthlyComputeUsd figure is compared against the credit allowance for each of the three plan tiers:

• Free: $5 credits, $0/month subscription, 5 concurrent runs, 7-day retention
• Starter: $49 credits, $49/month subscription, 25 concurrent runs, 30-day retention
• Scale: $499 credits, $499/month subscription, 100 concurrent runs, 90-day retention

For each plan, fits is set to true if monthlyComputeUsd <= creditsIncluded. The overage field is max(0, monthlyComputeUsd - creditsIncluded). totalCost is monthlyCost + overage.

Phase 4 — Recommendation and tips

The cheapest-fit algorithm filters planComparison to entries where fits === true, sorts by monthlyCost ascending, and selects the first result. If no plan fits (usage exceeds $499), the recommendation defaults to "Scale" with a note to consider overage or Enterprise pricing.

Three tip conditions are evaluated independently:

1. If avgMemoryMb > 2048, flag high memory consumption
2. If totalRuns > 1000 and recommendation is Free, flag credit exhaustion risk
3. If monthlyComputeUsd < 10 and recommendation is not Free, flag that Free is viable

Tips for best results

1. Run at the end of your billing cycle. The 30-day rolling window best represents your steady-state usage when you run Plan Advisor a few days before billing resets. Running it right after a billing cycle starts may undercount usage.

2. Interpret the actor cap carefully. The analysis covers up to 50 actors. If your account has 100+ actors, the remaining actors' compute is not included. The actorsAnalyzed field tells you the coverage. Accounts with many actors may want to cross-check against the Apify billing dashboard.

3. Act on memory tips immediately. If the tips section flags high average memory, that is the fastest lever to reduce your compute bill. An actor running at 4,096 MB that only needs 512 MB costs 8x more than necessary. Use the Actor Quality Audit to find specific actors with over-allocated memory.

4. Schedule it monthly. Add a 0 0 28 * * cron schedule so the advisor runs near the end of each month. This creates a monthly audit trail in your dataset history and alerts you to plan drift before it causes a surprise invoice.

5. Do not use it as a real-time cost tracker. Plan Advisor is a monthly snapshot, not a continuous monitor. For day-to-day overspend alerts, combine it with Cost Watchdog, which tracks spending continuously and can trigger alerts.

6. Run it on client accounts separately. If you manage Apify accounts for multiple clients, run Plan Advisor once per account using each client's API token. The results are scoped entirely to the account whose token is used.

7. Cross-reference with the cost calculator. If the recommendation surprises you, use Actor Cost Calculator to model the cost of individual actors. This helps identify which specific actors are driving most of your compute spend.

Combine with other Apify actors

Limitations

• 50-actor cap on run history. Accounts with more than 50 actors will have their analysis truncated. The remaining actors' compute spend is not counted, which means the recommendation may underestimate true usage for large portfolios.
• 100 runs per actor per fetch. Only the most recent 100 runs per actor are retrieved. High-volume actors that execute hundreds of runs per day may have their full monthly cost undercounted.
• No real-time billing data. The actor reads run-level usageTotalUsd fields, not the Apify billing API directly. There may be a small discrepancy between this figure and your actual invoice due to platform fees, storage, and proxy charges not reflected in run compute costs alone.
• Three plans only. The model covers Free, Starter, and Scale. Business and Enterprise plan pricing is not modeled because those tiers involve custom pricing. If you are considering Enterprise, use the Scale overage figure as a starting point for your conversation with Apify sales.
• 30-day rolling window, not calendar month. The analysis window is 30 × 24 × 60 × 60 × 1,000 milliseconds from the current timestamp. This is close to, but not identical to, your actual billing cycle dates.
• No proxy spend breakdown. Proxy data transfer costs (per GB) are not included in the per-run usageTotalUsd. The plan comparison includes proxy GB allowances in the plan metadata but cannot measure your actual proxy consumption.
• Single account only. Each run analyzes one account. Managing 10 client accounts requires 10 separate runs.

Integrations

• Zapier — trigger Plan Advisor monthly and post the recommendation to a Slack channel or update a Notion billing tracker automatically
• Make — build a billing review workflow that runs Plan Advisor, formats the output, and emails a monthly cost summary to your team
• Google Sheets — pipe monthly Plan Advisor results into a Google Sheet to build a trailing 12-month cost-vs-plan history
• Apify API — integrate into internal billing dashboards or developer portals using the REST API
• Webhooks — trigger a webhook on run completion to push the recommendation into your billing management system
• LangChain / LlamaIndex — use Plan Advisor output as a tool in an AI cost-management agent that can reason about when to upgrade or downgrade

Troubleshooting

• Output shows very low run count despite active account — This usually means most of your actors were created recently, or the first 50 actors in your list are low-traffic while the high-traffic actors are later in the list. The Apify API returns actors in creation order. If the mismatch is significant, cross-check against your Apify billing dashboard.

• Recommendation says Free but you know your compute is higher — The 50-actor and 100-run-per-actor caps may be causing undercounting. Check actorsAnalyzed against totalActors in the output. If coverage is below 80%, the figure may be an underestimate for large portfolios.

• Run fails with "Failed to list actors" — This indicates an API authentication issue. Verify that the actor is running under your own account (not a shared workspace where the token may have restricted permissions). The APIFY_TOKEN environment variable must be set to a token with read access to actors and runs.

• Tips section is empty — Empty tips are normal if your usage is moderate and memory allocation is under 2,048 MB average. No tips means no obvious optimization flags were detected.

• Scale is recommended but you expected Starter — Check monthlyComputeUsd in the output. If it exceeds $49, Scale is the correct recommendation. If you believe the figure is inflated, look for actors with unusually high usageTotalUsd per run using the Actor Revenue Analytics actor.

Responsible use

• This actor only accesses your own Apify account data via the API.
• No third-party websites are scraped or accessed.
• The API token used is scoped to your account — no data from other Apify accounts is accessible.
• Do not share the actor's output if it contains sensitive run metadata from internal business processes.

FAQ

Which Apify plan should I use based on my usage?

Plan Advisor answers this directly. Run the actor and it compares your last 30 days of compute spend against every plan tier. The recommendation field in the output names the cheapest plan that fits. You do not need to do any math yourself.

How does Plan Advisor calculate my monthly compute spend?

It calls the Apify API to fetch runs from the last 30 days across your actor portfolio (up to 50 actors, 100 runs each), then sums the usageTotalUsd field from each run. This gives a compute-only total in USD, which is the primary variable that determines plan fit.

Does Plan Advisor cover more than three plan tiers?

Currently, the model covers Free ($5 credits), Starter ($49 credits), and Scale ($499 credits). Business and Enterprise plans involve custom pricing and are not modeled. If your usage exceeds $499/month in compute, the actor recommends Scale and notes that you should consider Enterprise pricing directly with Apify.

How accurate is the plan recommendation?

The recommendation is accurate for compute costs. It does not factor in proxy data transfer charges or storage costs, which appear separately on your Apify invoice. For most users, compute is the dominant cost. Users with heavy proxy usage should treat the recommendation as a floor, not a ceiling.

How long does a Plan Advisor run take?

Typically 30–90 seconds depending on account size. For an account with 50 actors and 100 recent runs each, the actor makes up to 51 API calls sequentially. The Apify API's rate limits are not typically reached at this volume.

Can I schedule Plan Advisor to run every month automatically?

Yes. Set a cron schedule of 0 0 28 * * on the actor to run it monthly near the end of your billing cycle. Each run produces a new dataset record, so you build a month-by-month history automatically.

How is Plan Advisor different from the Apify billing dashboard?

The Apify billing dashboard shows what you have already spent. Plan Advisor tells you which plan would have been cheapest for that spend, and models whether you should be on a different plan going forward. It also flags memory inefficiencies that the billing dashboard does not surface.

What happens if my usage exceeds all plan tiers?

If your monthlyComputeUsd exceeds $499, no plan returns fits: true. In this case, recommendation is set to "Scale" and the reasoning field notes that your usage exceeds standard plans and suggests evaluating Scale with overage pricing or contacting Apify for Enterprise pricing.

Can I run Plan Advisor on a client's Apify account?

Yes. Run the actor from within the client's Apify account (logged in as them, or using their API token in a triggered run). The analysis is fully scoped to whichever account's token the platform injects. Running it from your own account analyzes your account only.

Is it safe to run Plan Advisor on a production account?

Yes. The actor is read-only — it calls only GET endpoints on the Apify API and does not modify any actors, runs, schedules, or settings. It cannot affect your production workloads in any way.

How much does Plan Advisor itself cost to run?

$0.25 per analysis, charged as a single pay-per-event charge when the run completes. There are no compute overage costs for the analysis itself — the $0.25 is inclusive of all platform resources used.

Why does Plan Advisor cap analysis at 50 actors?

The 50-actor cap prevents the analysis from timing out on large portfolios. Fetching 100 runs per actor for 200 actors would require 200 sequential API calls, which can exceed Apify's 5-minute actor timeout. The cap ensures the run completes reliably. For accounts with 50+ actors, cross-check the result against your billing dashboard to account for the uncovered actors.

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.