Serverless Functions Pricing: Examples & Companies

What is it

Serverless functions pricing is pricing for serverless function platforms, billed per invocation plus compute time consumed.

The defining trait is that it is two-dimensional. A platform charges once for how often a function runs (the invocation count) and again for what each run consumes (compute time plus memory). With no provisioned server, an idle function costs nothing — you pay only when code executes. This is the “Function-as-a-Service” (FaaS) or Lambda-style model, and five companies in the UsagePricing corpus build their billing around it: Vercel, Modal, Upstash, Trigger.dev, and Pipedream.

The variable that actually moves the bill is the unit of compute time. Some platforms bill wall-clock duration — the entire span a function is alive, including time spent waiting on a database or upstream API. Others bill only active CPU time and treat I/O wait as free. On an I/O-heavy workload the difference can be 5–10x on the identical code, which is why Vercel’s 2025 switch from wall-clock to Active CPU billing was the category’s most consequential pricing move.

How it works

A serverless function bill is built from a small set of metered dimensions, summed after an included free quota. The dimensions and how each company on this page rates them:

The compute-time unit (charted above) is the pivotal choice, but the same rate card still resolves to a concrete number. Two worked examples show how the summed dimensions land:

Unit math (Vercel Pro): Function cost = (invocations − 1M) × $0.60/M + (Active CPU-hours × $0.128) + (memory GB-hours × $0.0106), drawn against the $20 monthly usage credit before metered overage begins.

Unit math (Modal): A lightweight function using 1 vCPU and 4 GiB for 60 seconds costs about $0.0008 — 60 × ($0.0000131 + 4 × $0.00000222) — because CPU and memory both bill per second, so seconds of work cost cents, not a rounded-up hour.

Upstash extends the same logic past compute: it meters the operation against a managed datastore — commands, messages, workflow steps, vector queries — so a function’s database scales to zero on the identical per-use basis. Steady workloads on any of the five can escape metering entirely for a flat plan (Upstash Fixed plans from $10/month, Modal’s $250/month Team tier) that trades per-unit cost for predictability.

Companies using this

Five companies in the corpus tag serverless functions as a primary use case, each approaching the model from a different workload: Vercel (functions inside its frontend cloud), Modal (Python-native compute for GPU and batch jobs), Upstash (serverless data billed per operation), Trigger.dev (background jobs billed per compute-second plus a per-run fee), and Pipedream (workflow automation on credit-metered compute). The table below lists each with its pricing model, billing units, and free-tier status.

Patterns observed

Scale-to-zero is the shared floor: idle functions cost nothing, and the bill accumulates only during execution. What differs is how finely a vendor slices the active time. Trigger.dev prices per second by machine size ($0.0000169–$0.00068/sec), so a short job on a small machine and a long job on a large one land on the same continuous curve rather than a step function — the closest any of these five comes to charging purely for the work done.

The free tiers here are among the most generous in the corpus, reflecting a developer-led, product-led motion where prototypes run free and convert once the app ships. Vercel’s Hobby tier bundles 1M invocations, 4 Active CPU hours, and 360 GB-hours of memory monthly; Modal’s Starter gives $30/month in compute credits (up to $10,000 for qualifying startups); Upstash offers a $0 tier on every one of its five products; Trigger.dev bundles $5/month of credits; and Pipedream’s Free plan includes 100 credits per month.

Counterexamples & variants

Upstash is the category’s most distinct variant: it applies serverless billing not to function execution but to data operations — the resource metered is a managed data store, not application code, yet the principle (pay per operation, zero idle cost) is identical. That symmetry is the point: Vercel functions and Upstash data compose a fully serverless stack where every layer scales to zero on the same logic.

Pipedream shows where the per-invocation-plus-compute model gets abstracted away. Rather than exposing raw invocation and CPU-second meters, it sells a hybrid subscription (Basic $29/mo, Advanced $49/mo, Connect $99/mo on annual billing) whose credits represent compute, layering a bundled AI-token allowance (1M–50M tokens/mo) on top. The buyer is a no-code automation builder, not an engineer wiring up GPU inference, so the billing deliberately hides the machine-level dimensions that matter to Modal’s customers.

What this means for buyers vs vendors

For buyers

Ask one question first: does the platform bill Active CPU or wall-clock time? On an I/O-bound workload — most web-API and LLM-proxy functions — the answer alone decides whether you overpay severalfold for the same code. Then profile your real traffic against the free-tier ceilings before you standardize, because these tiers are sized for prototyping and saturate fast once a production app is live; a bill that is free in a demo can jump the moment traffic is real. The introduction to usage-based pricing and choosing the right usage metric both cover how to read a function-level meter before you commit.

For vendors

Serverless billing fits any platform where customers run code in response to events — webhooks, API requests, scheduled jobs, inference calls. The one design decision that matters is compute-time denomination, and each option is a different bet: Active CPU aligns the bill with genuine work and reads as a customer-friendly innovation; per-second machine rates read as transparent; a credit abstraction trades precision for a simpler mental model. Pick the one that matches who signs the invoice. Then keep a free tier large enough for real prototyping, not toy examples — it is the PLG on-ramp the whole category runs on. The usage-based pricing implementation guide covers designing the metering pipeline underneath.

Explore this theme in the knowledge graph →