Pricing (/docs/compute/pricing)

For the complete Prisma documentation index, see llms.txt. A markdown version of any docs page is available by appending .md to its URL.

How Prisma Compute pricing works, with the usage rates, included usage by plan, and worked examples.

Location: Compute > Pricing

Compute pricing is usage-based. Every plan includes a monthly request allowance, and the meters below cover the work your app does. An idle app scales to zero and costs nothing.

Each meter measures a different resource: how often your app runs (requests), how much memory it holds and CPU it uses while running (provisioned memory and active CPU), and how much data it sends back (outbound bandwidth).

The Free plan includes monthly limits for all four meters and has no usage billing. Paid plans include a monthly request allowance, then bill additional requests and the other three meters at the rates above.

See the pricing page for what each plan includes across Prisma Compute and Prisma Postgres.

The three examples below show how the same rates add up for different kinds of apps, from a short-lived preview to a bandwidth-heavy service.

These examples are estimates, not benchmarks. The inputs are round numbers so you can follow the math, and every meter is priced from zero. In practice your plan's included requests cover the request line first.

A pull request might deploy a preview several times as an agent fixes and tests a change.

Assume the preview gets 10,000 requests, stays running for 3,000s at 1 GB, uses 600 vCPU-seconds of active CPU, and sends 0.25 GB of data out.

Only the usage is billed; the deploys and the preview branch itself are not.

Agent work often spends more time waiting on other services than running on the CPU.

Assume an app runs 10,000 agent tasks in a month. Each task takes 30s wall-clock time, mostly waiting on a model API or another service. Together, the tasks stay running for 300,000s at 1 GB, use 30,000 vCPU-seconds of active CPU, and send 5 GB of data out.

While a task waits it uses almost no CPU, so active CPU stays low. But the app keeps running the whole time, so it holds its memory and you pay for that. This is why Compute bills provisioned memory separately from active CPU.

If your app streams responses, returns large results, or serves file downloads, bandwidth can make up most of the bill instead of compute. It is worth estimating this before you ship.

Assume an app serves 50,000 requests in a month, stays running for 15,000s at 1 GB, uses 1,500 vCPU-seconds of active CPU, and sends 200 GB of data out.

Here compute is almost free and bandwidth is nearly the whole bill. If your app moves a lot of data, estimate bandwidth first.

To estimate any month yourself, subtract your plan's included requests, then add up the four meters at their rates:

bill =
  max(0, requests - included_requests) * 1.00 / 1_000_000
  + provisioned_memory_gb_hours * 0.006
  + active_vcpu_hours * 0.064
  + outbound_bandwidth_gb * 0.025

You pay for the work your app does, not for resources sitting idle. These are not billed on their own:

• Deployments
• Preview branch creation
• Inactive apps
• Apps that have scaled to zero
• A Prisma-specific compute unit

A preview branch only costs money when it does work, such as serving traffic or running a background task. Creating one is free.

Database usage is available from the CLI (postgres usage) and API, including as JSON, and an agent can read it to estimate a cost, explain a change, or suggest a fix. Equivalent usage reporting for Compute is still being built.

Outbound bandwidth is the data your app sends from Compute to the public internet; inbound requests don't count. Small JSON or API responses use little of it, while streaming, file downloads, and media use much more. If your app moves a lot of data, estimate bandwidth before you ship.

If a rate, meter, or included amount doesn't match how your app actually runs, tell us in the prisma-compute channel on our Discord.

• Prisma Compute vs Vercel pricing: the same monthly workload priced line by line on both platforms.
• Get started: deploy your first app to a live URL.
• Known limitations: what Compute can and can't do.
• FAQ: quick answers to common questions.
• Branching: how preview branches isolate work and when they cost money.

• Alchemy: Provision Prisma Postgres and deploy applications to Prisma Compute in one TypeScript stack.
• Branching: Branches are isolated environments that map to your Git branches, so preview work never touches production.
• Deploy Button: Add a Deploy with Prisma button that copies a public Composer repository and starts a Composer-managed deployment.
• Deploy on push: Graduate a Composer app from manual deploys to a Git workflow, with production deploys on push and an isolated preview environment per branch.
• Deployments: How deploys create service versions on Prisma Compute, and how to inspect, promote, roll back, start, and stop them.