# Pricing (/docs/compute/pricing)

> For the complete Prisma documentation index, see [llms.txt](https://www.prisma.io/docs/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.

## Usage rates [#usage-rates]

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).

| Meter              | Price                | What it means                                                                         |
| ------------------ | -------------------- | ------------------------------------------------------------------------------------- |
| Requests           | `$1 per million`     | Every inbound request your app handles, after your plan's included requests.          |
| Provisioned memory | `$0.006 / GB-hour`   | Memory allocated while your app is running or intentionally kept awake.               |
| Active CPU         | `$0.064 / vCPU-hour` | CPU time your app actually consumes.                                                  |
| Outbound bandwidth | `$0.025 / GB`        | Data your app sends out to the internet. Incoming requests do not count as bandwidth. |

## Included usage by plan [#included-usage-by-plan]

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.

| Plan     | Monthly price | Requests included | Provisioned memory included | Active CPU included | Outbound bandwidth included | Requests beyond that |
| -------- | ------------- | ----------------- | --------------------------- | ------------------- | --------------------------- | -------------------- |
| Free     | `$0`          | 1M                | 360 GB-hours                | 4 vCPU-hours        | 10 GB                       | No usage billing     |
| Starter  | `$10`         | 5M                | Billed per use              | Billed per use      | Billed per use              | `$1 per million`     |
| Pro      | `$49`         | 20M               | Billed per use              | Billed per use      | Billed per use              | `$1 per million`     |
| Business | `$129`        | 100M              | Billed per use              | Billed per use      | Billed per use              | `$1 per million`     |

See the [pricing page](https://www.prisma.io/pricing) for what each plan includes across Prisma Compute and Prisma Postgres.

## Example costs by workload [#example-costs-by-workload]

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.

### Preview workflow [#preview-workflow]

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.

| Meter              | Estimate                                                 |
| ------------------ | -------------------------------------------------------- |
| Requests           | `10,000 * $1.00 / 1M = $0.0100`                          |
| Provisioned memory | `3,000s at 1 GB = 0.833 GB-hours * $0.006 = $0.0050`     |
| Active CPU         | `600 vCPU-seconds = 0.167 vCPU-hours * $0.064 = $0.0107` |
| Outbound bandwidth | `0.25 GB * $0.025 = $0.0063`                             |
| Total              | `$0.0320`, about `$0.03`                                 |

Only the usage is billed; the deploys and the [preview branch](https://www.prisma.io/docs/compute/branching) itself are not.

### Agent workflow [#agent-workflow]

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.

| Meter              | Estimate                                                   |
| ------------------ | ---------------------------------------------------------- |
| Requests           | `10,000 * $1.00 / 1M = $0.0100`                            |
| Provisioned memory | `300,000s at 1 GB = 83.33 GB-hours * $0.006 = $0.5000`     |
| Active CPU         | `30,000 vCPU-seconds = 8.33 vCPU-hours * $0.064 = $0.5333` |
| Outbound bandwidth | `5 GB * $0.025 = $0.1250`                                  |
| Total              | `$1.1683`, about `$1.17`                                   |

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.

### High-transfer workflow [#high-transfer-workflow]

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.

| Meter              | Estimate                                                   |
| ------------------ | ---------------------------------------------------------- |
| Requests           | `50,000 * $1.00 / 1M = $0.0500`                            |
| Provisioned memory | `15,000s at 1 GB = 4.167 GB-hours * $0.006 = $0.0250`      |
| Active CPU         | `1,500 vCPU-seconds = 0.417 vCPU-hours * $0.064 = $0.0267` |
| Outbound bandwidth | `200 GB * $0.025 = $5.0000`                                |
| Total              | `$5.1017`, about `$5.10`                                   |

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

## Formula to estimate your bill [#formula-to-estimate-your-bill]

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

```text
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
```

## What is not billed separately [#what-is-not-billed-separately]

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.

## Usage data for humans and agents [#usage-data-for-humans-and-agents]

Database usage is available from the [CLI](https://www.prisma.io/docs/cli/postgres) (`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.

## Bandwidth [#bandwidth]

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.

## Share your pricing feedback [#share-your-pricing-feedback]

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](https://pris.ly/discord).

## What to read next [#what-to-read-next]

* [Prisma Compute vs Vercel pricing](https://www.prisma.io/blog/prisma-compute-vs-vercel-pricing?utm_source=docs): the same monthly workload priced line by line on both platforms.
* [Get started](https://www.prisma.io/docs/compute/getting-started): deploy your first app to a live URL.
* [Known limitations](https://www.prisma.io/docs/compute/limitations): what Compute can and can't do.
* [FAQ](https://www.prisma.io/docs/compute/faq): quick answers to common questions.
* [Branching](https://www.prisma.io/docs/compute/branching): how preview branches isolate work and when they cost money.

## Related pages

- [`Alchemy`](https://www.prisma.io/docs/compute/alchemy): Provision Prisma Postgres and deploy applications to Prisma Compute in one TypeScript stack.
- [`Branching`](https://www.prisma.io/docs/compute/branching): Branches are isolated environments that map to your Git branches, so preview work never touches production.
- [`Deploy Button`](https://www.prisma.io/docs/compute/deploy-button): Add a Deploy with Prisma button that copies a public Composer repository and starts a Composer-managed deployment.
- [`Deploy on push`](https://www.prisma.io/docs/compute/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`](https://www.prisma.io/docs/compute/deployments): How deploys create service versions on Prisma Compute, and how to inspect, promote, roll back, start, and stop them.