# 💸 Heroku Cost Calculator — Migration Pricing Tool (`nexgendata/heroku-cost-calculator`) Actor

Estimate your current Heroku bill and compare migration costs across Railway, Render, Fly.io, Cloudflare Workers + D1, and DigitalOcean App Platform. Returns recommended target + step-by-step migration outline. Pricing updated Q1 2026.

- **URL**: https://apify.com/nexgendata/heroku-cost-calculator.md
- **Developed by:** [Stephan Corbeil](https://apify.com/nexgendata) (community)
- **Categories:** Developer tools, Automation, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

$50.00 / 1,000 heroku bill estimate + multi-host comparisons

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## 💸 Heroku Cost Calculator — Migration Pricing Tool

> **The fastest way to answer "how much will I save by leaving Heroku?"** — compare your current Heroku bill against Railway, Render, Fly.io, Cloudflare Workers + D1, and DigitalOcean App Platform in one run. Get a recommended target and a concrete, step-by-step migration outline.

[![Try it on Apify](https://apify.com/actor-badge?actor=nexgendata/heroku-cost-calculator)](https://apify.com/nexgendata/heroku-cost-calculator?fpr=2ayu9b)

---

### Why this exists

On **28 November 2022**, Heroku eliminated its free product tiers — free dynos, free Postgres, free Redis — ending a ten-year run that had onboarded an entire generation of developers onto the platform. Millions of side projects went dark overnight. What followed was a slow but steady exodus of paying customers, too: teams who looked at their monthly bill, looked at the feature-set they were actually using, and realized they were overpaying for a 2015-era developer experience.

Three years later, the question hasn't gone away. New devs keep landing on Heroku tutorials from 2018, deploying their first app, then wondering why their $0 prototype is suddenly $32/month (one Basic dyno + Basic Postgres + Mini Redis + one addon). Established teams keep staring at five-figure Heroku invoices wondering which of the modern alternatives — **Railway**, **Render**, **Fly.io**, **Cloudflare Workers**, **DigitalOcean App Platform** — would actually save them money without tanking productivity.

This actor answers that question in under two seconds, for free, with **no login, no scraping, and no API keys required.**

### What this actor does

You describe your current Heroku stack:

- How many dynos of which tier (Eco, Basic, Standard-1X, Standard-2X, Performance-M, Performance-L)
- Your Postgres plan (Mini through Premium)
- Your Redis plan (optional)
- How many paid addons you run
- Your migration priority (cost, simplicity, or performance)

The actor computes:

1. **Your current Heroku monthly bill** (hardcoded Heroku public pricing)
2. **Equivalent monthly cost on each of the 5 alternative platforms**
3. **A migration complexity score (1-5)** per platform, grounded in real migration friction — *not random numbers*
4. **The recommended target** for your specific priority and team size
5. **A step-by-step migration outline** for the winner, from CLI install to DNS cutover

Everything is a pure calculation — no external API calls, no rate limits, no anti-bot risk. Pricing data was pulled from the public pricing pages of each vendor in Q1 2026.

### Input parameters

| Field | Type | Description | Default |
|---|---|---|---|
| `dynos` | array of `{type, count}` | Your Heroku dynos. Types: `eco`, `basic`, `standard-1x`, `standard-2x`, `performance-m`, `performance-l` | `[{type: "standard-1x", count: 1}]` |
| `postgres_plan` | enum | `none`, `mini`, `basic`, `standard-0`, `standard-2`, `premium-0` | `basic` |
| `redis_plan` | enum | `none`, `mini`, `premium-0`, `premium-1` | `none` |
| `addons` | array of strings | Names of paid Heroku addons (Papertrail, SendGrid, etc.) | `[]` |
| `custom_domains` | int | Number of custom domains (informational, for DNS cutover planning) | `1` |
| `team_size` | int | Developers touching the migration — affects recommendation | `1` |
| `migration_priority` | enum | `cost`, `simplicity`, or `performance` | `cost` |

### Output schema example

```json
{
  "current_heroku_cost_usd": 84.0,
  "input_summary": { "...echo of input..." },
  "alternatives": [
    {
      "platform": "Railway",
      "estimated_cost_usd": 13.18,
      "migration_complexity": 2,
      "pros": ["Closest Heroku UX — git push deploys", "..."],
      "cons": ["Usage billing can surprise at scale", "..."]
    },
    {
      "platform": "Render",
      "estimated_cost_usd": 34.0,
      "migration_complexity": 2,
      "pros": ["..."], "cons": ["..."]
    }
  ],
  "recommended_platform": "Railway",
  "recommendation_rationale": "Based on priority='cost' and team_size=1, Railway offers the best fit at $13.18/mo (vs Heroku $84.0/mo, saving $70.82/mo or 84.3%)...",
  "estimated_monthly_savings_usd": 70.82,
  "estimated_savings_pct": 84.3,
  "migration_outline": [
    "Sign up at railway.app and install the Railway CLI...",
    "In your Heroku app root run `railway login` then `railway init`...",
    "...8+ more concrete steps..."
  ],
  "pricing_last_updated": "2026-Q1"
}
````

### Pricing matrix at a glance

| Component | Heroku | Railway | Render | Fly.io | Cloudflare | DO App |
|---|---|---|---|---|---|---|
| 1 small web dyno (512 MB) | $7-25 | ~$5 usage | $7 | ~$2-5 | $5 flat | $5-12 |
| Postgres (10M rows) | $9 | $5 | $7 | $0-7 self | N/A (use D1) | $15 |
| Redis (50 MB HA) | $15 | $10 | $30 | $10 via Upstash | KV free tier | $30 |
| Free web tier? | ❌ killed Nov 2022 | ❌ $5 min | ✅ (cold starts) | ✅ (shared) | ✅ (10ms CPU) | ❌ |
| Heroku-familiar UX? | — | ★★★★★ | ★★★★☆ | ★★★☆☆ | ★☆☆☆☆ | ★★★★☆ |

### Five real use cases

**1. The indie hacker with a dying side project**
You launched a SaaS in 2020, got laid off during free-tier sunset, and now pay $32/mo to keep a Basic dyno + Basic Postgres alive for 4 paying users. Run this actor → it recommends **Railway** at ~$8/mo, saving $288/year. Migration takes an afternoon.

**2. The YC seed startup scaling past $500/mo**
You have 3 Standard-2X dynos, 2 worker dynos, Standard-0 Postgres, Premium-0 Redis, and five addons. Heroku bill: ~$420/mo. Actor recommends **DigitalOcean App Platform** at ~$180/mo (simplicity priority, team of 5 engineers). Payback on migration: under 2 months.

**3. The agency running 30 client apps**
Batch-run the actor across all 30 apps. Half land on Render (predictable flat tiers the client finance teams understand), half on Railway (usage-based for low-traffic sites). Aggregate savings: $9K/year across the portfolio.

**4. The CTO doing platform due diligence**
Board asked "why are we still on Heroku?" You run the actor three times with different `migration_priority` settings and paste the JSON into your memo. Bonus: the complexity scores give you a defensible engineering-effort estimate.

**5. The edge-curious Next.js dev**
You want to go serverless-all-the-way. Set priority to `performance`. Actor recommends **Cloudflare Workers + D1** at ~$10/mo and warns you upfront: "WARNING — this is not a lift-and-shift, you will rewrite your HTTP handlers." Honest, so you can plan the quarter correctly.

### Alternative platform rundown

**Railway** is the closest spiritual successor to classic Heroku. Procfile-compatible, `railway up` feels like `git push heroku master`, and one-click plugins provision Postgres / Redis / MySQL in 10 seconds. Usage-based billing ($0.000231/GB-hour RAM + $0.000463/vCPU-hour) means tiny apps cost pennies, but busy workloads can surprise you — model your traffic before committing.

**Render** is what Heroku would have built if they had kept iterating. Dashboard-first, render.yaml for infra-as-code, zero-downtime deploys, native Docker + static sites + cron jobs + private services. Managed Postgres starts at $7/mo. The **free web tier still exists** (sleeps after 15 min idle), making Render the natural landing spot for hobby projects displaced in November 2022.

**Fly.io** is the cheapest platform once you understand it. Shared-CPU machines billed per second, 35+ regions, first-class Docker, and a Postgres offering you operate yourself (not "managed" in the Heroku sense — you own backups and failover). Deployments are CLI-only via `flyctl`. Excellent for latency-sensitive, geographically distributed apps. Steeper learning curve than Railway or Render.

**Cloudflare Workers + D1** is a completely different paradigm — V8 isolates at the edge, not long-lived processes. You don't "migrate" a Rails app here; you rewrite HTTP handlers (Hono, itty-router) and swap Postgres for D1 (SQLite) or front Postgres with Hyperdrive. Payoff: near-zero cost at massive scale and zero cold starts globally. The actor flags complexity=4-5 when you pick this and your stack is Postgres-heavy, because it's trying to save you from a bad quarter.

**DigitalOcean App Platform** is the boring, predictable, flat-fee option. Basic tier $5/mo, Professional $12/mo, Premium $25/mo. Managed Postgres from $15/mo with daily backups. No usage surprises, familiar dashboard, tight integration with DO Droplets and Spaces. Great for teams who want Heroku's flat-tier predictability without Heroku's 2015 pricing.

### Why NexGenData

- **Batch-mode support** — run this actor against 100 Heroku apps in one Apify job, export a CSV of per-app savings for your CFO
- **PPE (pay-per-event) pricing** — pay only per calculation, no subscription
- **No login, no API key** — run it anonymously via Apify's free tier
- **Transparent source** — pricing constants are in `src/main.py`, open for audit
- **Maintained quarterly** — we re-verify pricing every quarter against vendor public pages

### Related actors from NexGenData

- **Company Tech Stack Detector** — identify what SaaS platforms a company uses (Heroku footprint, CDN, analytics) before reaching out
- **Domain WHOIS Lookup** — verify domain ownership and age during migration DNS planning
- **Page Speed Analyzer** — benchmark latency pre- and post-migration to prove the perf win to your team

### FAQ

**Q: How accurate is the cost estimate?**
A: Pricing constants are from public vendor pages as of Q1 2026, accurate to the month. Your actual bill will vary based on traffic, egress, storage growth, and specific region choices. Think of this as a planning tool, not an invoice predictor — most teams land within 15% of the estimate.

**Q: My Heroku addon isn't in your list — how is it priced?**
A: We use a $10/mo flat estimate per paid addon as a rough floor. For exact numbers, check the Heroku Elements marketplace and add manual adjustments. Common alternatives: Papertrail → Better Stack Logs, Bonsai → Elastic Cloud, SendGrid → Resend, Scheduler → platform-native cron (all 5 alternatives have cron built in).

**Q: Can I run this for a Kubernetes migration too?**
A: Not directly — this actor compares Heroku against PaaS alternatives. For K8s migration sizing, look at cloud-provider-specific calculators (EKS, GKE, AKS). K8s only makes sense above ~$2K/mo of PaaS spend and with an ops team to run it.

**Q: Why no AWS / GCP / Azure in the comparison?**
A: Those are IaaS, not PaaS — apples-to-oranges. AWS Elastic Beanstalk and Google App Engine are closer, but their pricing models are opaque enough that a generic calculator would mislead more than help. Future versions may add Beanstalk + App Engine behind a flag.

**Q: What if I'm on Heroku Private Spaces or Shield?**
A: This calculator assumes Heroku Common Runtime pricing. Private Spaces (~$1,000/mo base) and Shield (~$3,000/mo base) are enterprise tiers with SOC 2 / HIPAA compliance — migration targets differ (usually Fly.io Enterprise, AWS GovCloud, or stay on Heroku). Email us for enterprise modeling.

**Q: Will this ever do an automated migration?**
A: No. Automated DB dumps and DNS cutovers are too risky to push-button. This actor gives you the *plan*; you execute it with appropriate maintenance windows and rollback testing.

***

**Ready to cut your Heroku bill?** [Run the actor on Apify →](https://apify.com/nexgendata/heroku-cost-calculator?fpr=2ayu9b)

*Built by NexGenData. Part of our developer-tools actor suite. Have a pricing-comparison idea? Open an issue or tweet at us.*

### Related tools

- [🧮 A/B Test Calculator — Statistical Significance](https://apify.com/nexgendata/ab-test-calculator?fpr=2ayu9b)
- [♿ WCAG 2.2 Accessibility Auditor — Bulk](https://apify.com/nexgendata/wcag-accessibility-auditor?fpr=2ayu9b)
- [🧱 Company Tech Stack Detector — BuiltWith Alternative](https://apify.com/nexgendata/company-tech-stack-detector?fpr=2ayu9b)
- [⚡ Page Speed Bulk Checker — Lighthouse at Scale](https://apify.com/nexgendata/page-speed-bulk-checker?fpr=2ayu9b)

# Actor input Schema

## `dynos` (type: `array`):

List of dynos you run on Heroku. Each object has a 'type' (eco, basic, standard-1x, standard-2x, performance-m, performance-l) and a 'count' (integer). Example: \[{"type": "standard-1x", "count": 2}, {"type": "performance-m", "count": 1}].

## `postgres_plan` (type: `string`):

Your current Heroku Postgres tier. Choose 'none' if you do not use Heroku Postgres. Pricing: mini $5, basic $9, standard-0 $50, standard-2 $200, premium-0 $200.

## `redis_plan` (type: `string`):

Your current Heroku Redis tier. Choose 'none' if you do not use Heroku Redis. Pricing: mini $3, premium-0 $15, premium-1 $60.

## `addons` (type: `array`):

List of paid Heroku addon names (e.g. Papertrail, SendGrid, Bonsai, Scheduler). Used to estimate addon replacement cost (average $10/mo per addon budget tier). Leave empty if you have no paid addons.

## `custom_domains` (type: `integer`):

Number of custom domains attached to your Heroku app. Most alternative platforms include custom domains + free TLS, so this is mostly informational for planning DNS cutover.

## `team_size` (type: `integer`):

Number of developers who will touch the migration. Influences recommendation: smaller teams lean toward simpler platforms (Railway, Render); larger teams can absorb complexity on Fly.io or Cloudflare.

## `migration_priority` (type: `string`):

What matters most for this migration? 'cost' minimizes monthly spend, 'simplicity' minimizes engineering effort, 'performance' favors edge / global low-latency platforms.

## Actor input object example

```json
{
  "dynos": [
    {
      "type": "standard-1x",
      "count": 1
    }
  ],
  "postgres_plan": "basic",
  "redis_plan": "none",
  "addons": [],
  "custom_domains": 1,
  "team_size": 1,
  "migration_priority": "cost"
}
```

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "dynos": [
        {
            "type": "standard-1x",
            "count": 1
        }
    ],
    "postgres_plan": "basic",
    "redis_plan": "none",
    "addons": [],
    "custom_domains": 1,
    "team_size": 1,
    "migration_priority": "cost"
};

// Run the Actor and wait for it to finish
const run = await client.actor("nexgendata/heroku-cost-calculator").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "dynos": [{
            "type": "standard-1x",
            "count": 1,
        }],
    "postgres_plan": "basic",
    "redis_plan": "none",
    "addons": [],
    "custom_domains": 1,
    "team_size": 1,
    "migration_priority": "cost",
}

# Run the Actor and wait for it to finish
run = client.actor("nexgendata/heroku-cost-calculator").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "dynos": [
    {
      "type": "standard-1x",
      "count": 1
    }
  ],
  "postgres_plan": "basic",
  "redis_plan": "none",
  "addons": [],
  "custom_domains": 1,
  "team_size": 1,
  "migration_priority": "cost"
}' |
apify call nexgendata/heroku-cost-calculator --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=nexgendata/heroku-cost-calculator",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "💸 Heroku Cost Calculator — Migration Pricing Tool",
        "description": "Estimate your current Heroku bill and compare migration costs across Railway, Render, Fly.io, Cloudflare Workers + D1, and DigitalOcean App Platform. Returns recommended target + step-by-step migration outline. Pricing updated Q1 2026.",
        "version": "0.0",
        "x-build-id": "4IvbzahNWY3fSw5KC"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/nexgendata~heroku-cost-calculator/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-nexgendata-heroku-cost-calculator",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/nexgendata~heroku-cost-calculator/runs": {
            "post": {
                "operationId": "runs-sync-nexgendata-heroku-cost-calculator",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/nexgendata~heroku-cost-calculator/run-sync": {
            "post": {
                "operationId": "run-sync-nexgendata-heroku-cost-calculator",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "dynos": {
                        "title": "Heroku Dynos",
                        "type": "array",
                        "description": "List of dynos you run on Heroku. Each object has a 'type' (eco, basic, standard-1x, standard-2x, performance-m, performance-l) and a 'count' (integer). Example: [{\"type\": \"standard-1x\", \"count\": 2}, {\"type\": \"performance-m\", \"count\": 1}]."
                    },
                    "postgres_plan": {
                        "title": "Heroku Postgres Plan",
                        "enum": [
                            "none",
                            "mini",
                            "basic",
                            "standard-0",
                            "standard-2",
                            "premium-0"
                        ],
                        "type": "string",
                        "description": "Your current Heroku Postgres tier. Choose 'none' if you do not use Heroku Postgres. Pricing: mini $5, basic $9, standard-0 $50, standard-2 $200, premium-0 $200.",
                        "default": "basic"
                    },
                    "redis_plan": {
                        "title": "Heroku Redis Plan",
                        "enum": [
                            "none",
                            "mini",
                            "premium-0",
                            "premium-1"
                        ],
                        "type": "string",
                        "description": "Your current Heroku Redis tier. Choose 'none' if you do not use Heroku Redis. Pricing: mini $3, premium-0 $15, premium-1 $60.",
                        "default": "none"
                    },
                    "addons": {
                        "title": "Heroku Addons",
                        "type": "array",
                        "description": "List of paid Heroku addon names (e.g. Papertrail, SendGrid, Bonsai, Scheduler). Used to estimate addon replacement cost (average $10/mo per addon budget tier). Leave empty if you have no paid addons.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "custom_domains": {
                        "title": "Custom Domains",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Number of custom domains attached to your Heroku app. Most alternative platforms include custom domains + free TLS, so this is mostly informational for planning DNS cutover.",
                        "default": 1
                    },
                    "team_size": {
                        "title": "Team Size",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Number of developers who will touch the migration. Influences recommendation: smaller teams lean toward simpler platforms (Railway, Render); larger teams can absorb complexity on Fly.io or Cloudflare.",
                        "default": 1
                    },
                    "migration_priority": {
                        "title": "Migration Priority",
                        "enum": [
                            "cost",
                            "simplicity",
                            "performance"
                        ],
                        "type": "string",
                        "description": "What matters most for this migration? 'cost' minimizes monthly spend, 'simplicity' minimizes engineering effort, 'performance' favors edge / global low-latency platforms.",
                        "default": "cost"
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```