---
title: "API Monetization"
description:
  "Price, bill, and meter your APIs from the gateway. Subscriptions, plan-scoped API keys, real-time metering, soft/hard quota enforcement, and a self-serve developer-portal pricing page."
canonicalUrl: "https://zuplo.com/features/api-monetization"
sourceUrl: "https://zuplo.com/features/api-monetization"
pageType: "feature"
generatedAt: "2026-10-08"
---

# Turn API traffic into revenue

> Your API already delivers value — it should be a revenue stream, not just an infrastructure cost. Meter usage, sell plans, and enforce quotas on the gateway you already run, and launch paid tiers in days.

Included on Free and Builder plans. Available on Enterprise. See [pricing](/pricing).

The hero shows a "Monetization Console" mock-up: MRR $48,312 (+8.2% MoM), 412 active subscriptions across 3 plans, 38 trialing (14-day default), $2,841 overage revenue this period. Highlights: real-time metering, automated subscriptions + invoicing, soft / hard limits + overage.

## Billing logic doesn't belong in your API code

Every API team that wants revenue ends up building the same metering, billing, and entitlement plumbing. Multiplied across thousands of teams, that's an enormous waste. The gateway already sees every request — it should be the meter, the entitlement check, and the bridge to billing.

- **Billing plumbing = your weekend** — You'd love to charge for usage. So you build a metering pipeline, batch jobs, billing reconciliation, a usage dashboard, and a way to surface limits to customers. Three sprints in, you're maintaining a billing system, not shipping the API.
- **Billing leakage eats 10–20% of API revenue** — Plan limits live in your docs, not your gateway. Customers blow through quotas, sales has to chase, and the CFO writes off the rest. Every "upgrade conversation" is two weeks of Slack instead of a button click.
- **Metering and access tied to two systems** — Your billing system knows the subscription. Your gateway knows the request. They drift. A customer downgrades, the gateway forgets, and they get pro features for another month.
- **AI cost passthrough is a math problem** — Each LLM call costs a different amount. Your customer sees it as a request. You see it as $0.04. Multiply by a thousand customers and the gross-margin spreadsheet looks worse every quarter.

## A complete monetization stack, built into the gateway

- **Billing wired up from day one** — Subscriptions, invoicing, payments, plan changes, proration, cancellation — handled out of the box. Zuplo manages entitlement and metering at the edge and stays in sync with your payment provider automatically, so the money side just works.
- **Real-time metering, not batch jobs** — Every request increments your meters in real time at the edge. No nightly reconciliation, no "why is the invoice off," no 14-day delay between usage and bill. The gateway is the meter.
- **Self-serve pricing page included** — Drop `zuploMonetizationPlugin` into your developer portal and a Pricing page, Subscription Management, and Usage Dashboard appear. Customers subscribe, upgrade, and watch their quota — your team stays in product.

## Compose any pricing model from the same primitives

Meters count things. Features connect meters to your product catalog. Plans bundle features into rate cards with prices and entitlements. Free tiers, pay-as-you-go, quotas with overages, credits, multi-currency — all the same building blocks.

`MonetizationInboundPolicy` · per route:

```json
{
  "name": "monetize-route",
  "policyType": "monetization-inbound",
  "handler": {
    "export": "MonetizationInboundPolicy",
    "module": "$import(@zuplo/runtime)",
    "options": {
      "cacheTtlSeconds": 60,
      "meters": {
        "api_requests": 1
      }
    }
  }
}
```

Multi-meter charge from your handler:

```ts
import { MonetizationInboundPolicy } from "@zuplo/runtime";

// Inside an LLM route handler
const tokens = countTokens(prompt) + countTokens(completion);
MonetizationInboundPolicy.setMeters(context, {
  api_requests: 1,
  tokens, // billed at rate-card rate
});
```

- Subscriptions & billing
- Plan-scoped API keys
- Real-time meters · 7 aggregations
- Soft/hard limit per feature
- Self-serve pricing + checkout
- Multi-currency · multi-cadence

Links: [Read the Quickstart](https://zuplo.com/docs/articles/monetization/quickstart), [Billing integration docs](https://zuplo.com/docs/articles/monetization/stripe-integration).

## Monetization that feels like a feature, not a project

- **First-party, not a passthrough** — `MonetizationInboundPolicy` isn't just a Stripe SDK wrapper. It's a meter, a quota engine, an entitlement check, and an API key gate — all running in the same edge runtime as the rest of your gateway, with Stripe as the billing system of record.
- **Bill on any unit that costs you** — Requests, tokens, GB transferred, compute credits, rows returned, AI calls, custom metrics from your backend — each maps to its own meter and rate card. One request can charge multiple counters. Cost passthrough for AI and data workloads stops being a spreadsheet exercise.
- **Plan-scoped API keys** — Subscribing generates an API key tied to the plan. Plan changes update entitlements without rolling the key. Cancellation revokes the key at period end, after Stripe finishes billing. One key per customer, the whole lifetime.
- **Soft + hard limits, configured per feature** — Hard limit on the trial tier: 429 at the cap. Soft limit on the paid tier: bill the overage at the rate-card rate. Trial users feel a wall; paid users feel an invoice. Both behaviors live in the same plan config.

## What teams use this for

**"Free tier with 1k calls, paid tier with 5k calls + overage."**
Set up two plans — a free Developer tier capped at 1k calls per month, and a $9.99/mo Pro tier with 5k calls included and per-call overage. Customers subscribe through your developer portal, checkout is handled for you, and Zuplo issues a plan-scoped API key. Live in an afternoon.

**"Charge customers for the AI tokens our backend actually used."**
Your backend returns the real token count in a response header (e.g. `x-tokens-used: 1834`). The gateway reads it, charges the customer for that exact amount on the tokens meter, and strips the header before the response goes out. No client-side math, no double-counting, no separate billing service.

**"Support needs to suspend a customer or move them to a different plan."**
From the admin UI or the Monetization API: suspend a consumer instantly (every request returns 403), migrate them between plans (entitlements update without rolling the key), or override a single customer's quota for one cycle. Customer ops doesn't need an engineering ticket.

**"API access has to follow our existing subscription system, not Stripe."**
Write a small custom policy that checks your subscription system (MemberStack, Salesforce, your own DB) before each request and denies access when the parent subscription lapses. Zuplo still meters and rate-limits — but entitlement is gated by the system you already bill from.

## Frequently asked questions

### How do I monetize an API?

API monetization means charging customers for the API calls or compute they consume. With Zuplo you set this up in three steps: define your plans and pricing in your gateway config, connect a payment provider, then put a monetization policy on the routes you want to bill. Customers subscribe through a self-serve pricing page, get an API key tied to their plan, and Zuplo handles entitlement, metering, and billing on every request — no custom billing service to build or maintain.

### Can I use Stripe to bill API customers?

Yes. Connect a restricted Stripe key, define your products and prices in Zuplo, and customers pay through Stripe Checkout. Zuplo is the source of truth for usage and entitlement; Stripe is the source of truth for payment state. Subscriptions, invoicing, proration, refunds, and dunning all run through Stripe; the gateway syncs lifecycle events automatically.

### How do I add a free tier and paid plans to my API?

Define each tier as a plan in Zuplo with its own quota, rate limits, and rate-card pricing — for example, a Free plan capped at 1,000 calls/month and a Pro plan with 50,000 calls included plus per-call overage. Drop the plans into your developer portal and customers can subscribe themselves. Upgrades, downgrades, and cancellations happen through the portal without a sales touch.

### How do I bill API customers by tokens or other custom usage units?

Most APIs cost more than just "requests" — AI tokens, GB transferred, rows returned, compute credits. Zuplo lets you define a meter for any unit and charge multiple meters per request. Have your backend return the actual usage in a response header (e.g. x-tokens-used: 1834); the gateway reads it, charges that exact amount, and strips the header before the response leaves. Cost passthrough for AI workloads stops being a spreadsheet exercise.

### What's the difference between soft and hard usage limits?

Hard limits cut customers off at the cap — every request after the limit returns 429 until the next cycle. Soft limits let traffic through but charge per-unit overage at your rate-card rate. Most teams use hard limits on free trials (so they don't run up a bill) and soft limits on paid plans (so customers don't hit a wall mid-integration). You can mix both per-feature inside the same plan in Zuplo.

### How do customers see their API usage and remaining quota?

Zuplo's developer portal includes a customer-facing usage dashboard out of the box — they see current-period consumption per metered feature, progress bars to their quota, the API keys they've issued, and their next invoice estimate. Enable the monetization plugin in your portal config and the UI is wired up automatically. Customers debug their own rogue scripts; your support team stops fielding "how much have I used" tickets.

### What's the best API gateway for SaaS monetization?

Most API gateways stop at routing, auth, and rate limits — for monetization you bolt on Stripe, build a metering pipeline, and reconcile usage to invoices yourself. Zuplo includes monetization as a first-class feature: subscriptions, real-time metering at the edge, plan-scoped API keys, soft/hard quotas, and a self-serve pricing page in the developer portal. AccuWeather replaced its Apigee + custom-billing stack with Zuplo and shipped a ChatGPT app on top in three clicks.

### How fast can I add monetization to an existing API?

Most teams launch a paid plan in days, not months. Sign up for a free Zuplo project, point it at your existing API as the origin, connect Stripe, and define plans matching the pricing you already want to charge. Existing routes don't need to change — Zuplo adds metering and entitlement in front of them. Talk to a Zuplo expert if you want a guided rollout that mirrors your current pricing model exactly.

### Can I use API Monetization in production today?

Yes. Fixed monthly quotas, quotas with overages, and pay-as-you-go billing models are all production-ready. Core billing flows — subscriptions via Stripe, real-time metering, quota enforcement, and plan-scoped API keys — are used by teams handling real payments today. When you're ready to go live, email sales@zuplo.com with your account slug, project slug, Stripe account ID, and target go-live date, and the Zuplo team will confirm your configuration and enable your project for live billing.

### What does API Monetization cost?

The Free tier and the Builder tier ($25/month) each include 100,000 monetization events per month — one event per metered API request — at no extra cost. Enterprise plans offer monetization as an add-on with custom event limits. There is no separate monetization fee on Free or Builder. Check the pricing page for full plan details.

## Next steps

- [Get a Pricing Demo](/schedule-call)
- [Start for Free](https://portal.zuplo.com/signup)
- [Read the Docs](https://zuplo.com/docs/articles/monetization)

Stop building billing plumbing. Ship pricing instead. Free Zuplo project, built-in subscriptions, and a self-serve developer portal — bill for your API in an afternoon.