June 9, 2026 · 6 min read

How to Earn Revenue When AI Agents Call Your API

More of your traffic is no longer human. Autonomous agents built on LangChain, CrewAI, AutoGen, and custom MCP stacks discover tools, call them, and move on without a person ever opening a browser. If your API does something an agent needs, that agent is already willing to pay for it. The question is whether you have a way to collect. This is a practical playbook for builders who want to earn revenue from AI agents instead of serving automated traffic for free.

The approach is deliberately small. You do not rebuild your stack, stand up a billing service, or sign an enterprise contract. You add one decorator to a function, set a price, test it in a safe mode, and flip a switch when you are ready. Revenue here is potential, not promised: what you actually earn depends entirely on your own traffic, your pricing, and the value your endpoint delivers. nano-empire-tollbooth is the tool that makes the mechanics trivial.

Step 1: Identify a Billable Function

Before you write any billing code, pick the right target. Not every endpoint should charge. You want a function that is expensive to run, valuable to the caller, and called repeatedly by automated clients. Good candidates are functions that wrap an LLM call, run a model, hit a paid downstream API, or perform real compute: document summarization, lead scoring, embedding generation, data extraction, classification.

The test is simple. If an agent would call this function many times in a workflow, and each call saves the caller real time or money, it is billable. A health check or a trivial string formatter is not. Charging for low-value calls just adds friction and gives callers a reason to route around you. Concentrate the toll on the one function that carries the value, and leave the rest open.

Once you have chosen the function, the rest takes minutes. Install the package from PyPI. It runs on Python 3.9+ and ships under the MIT license.

terminalpip install nano-empire-tollbooth

Step 2: Add the Tollbooth Decorator and Set a Price

The package exposes a single decorator, @monetize. You attach it to your billable function and pass one argument: the price per call in USD. That is the entire integration. The decorator wraps your function with a tollbooth that meters every call, writes a record to a local ledger, and gates access once the free allotment is used.

pythonfrom nano_empire_tollbooth import monetize

@monetize(price_usd=0.01)
def summarize(text: str) -> str:
    """Summarize a document. Priced per call for agent callers."""
    return my_llm(text)

result = summarize("Long document text goes here ...")
print(result)

Setting the price is a judgment call, not a formula. Price it against what the call is worth to the agent and what it costs you to serve. The figures in this post are illustrative: a function that wraps a cheap model might sit at $0.01 per call, while one running heavier compute might be $0.05 or more. You can change the number any time by editing the argument. Async functions work the same way, which matters because most agent-facing code is asynchronous.

pythonfrom nano_empire_tollbooth import monetize, get_usage

# Async is a first-class path
@monetize(price_usd=0.05)
async def translate(text: str, lang: str) -> str:
    return await my_async_llm(text, lang)

# Inspect call counts per function at any time
print(get_usage())  # {'__main__.summarize': 42, '__main__.translate': 7}

Your billing logic now lives next to your business logic. There is no separate middleware layer, no webhook endpoint, and no subscription state to reconcile. For a side-by-side on how this differs from rolling your own payment stack, see Stripe vs Nano Empire.

Step 3: Test in Paper Mode

Do not point a new billing path at live money on day one. The tollbooth starts in paper mode by default. In paper mode the full flow runs end to end: calls are metered, records are written to a local JSONL ledger, and escrow lifecycle logic executes, but no real charge settles. The first 100 calls run free this way, which gives you a realistic dry run and gives your callers a genuine trial before anyone pays.

Use this window to confirm the behavior you expect. Run your function, watch the call counts increment, and verify the ledger entries match. You can also configure a per-agent daily cap so a single runaway caller cannot accrue unbounded charges, which is worth setting before you ever go live.

pythonfrom nano_empire_tollbooth import TollboothConfig, create_tollbooth

config = TollboothConfig(
    toll_per_message_usd=0.01,    # default rate
    paper_mode=True,              # dry run, no real settlement
    max_daily_toll_per_agent=10,  # cap exposure per caller
)
booth = create_tollbooth(config)

If you want to exercise payment flows without wiring anything up, the Tollbooth Simulator lets you run scenarios in a sandbox. Reading the quickstart guide alongside it will get the configuration details straight before you commit to live mode.

Step 4: Switch to Live and Read the Ledger

When the dry run looks correct, you flip from paper to live. Paper mode stays free forever, including the 100-call allowance per caller. To accept real payments you move to Tollbooth Pro at $19/mo, which unlocks live settlement via the x402 protocol, escrow on each charge, and cloud sync on top of the local ledger. Live mode is where an agent pays real USD per call, with funds locked in escrow and released on delivery.

The switch itself is a single change. You can set it in config or with an environment variable, so promoting from staging to production does not require touching code:

terminalexport TOLLBOOTH_PAPER_MODE=false

Your function signature does not change and your callers do not need to update their integration. The only difference is that settlement is now real. After calls start flowing, read the ledger to see exactly what happened. Every charge is one JSON object per line, append-only, which makes it straightforward to audit and to roll up into whatever reporting you already run.

pythonimport json

with open("logs/toll_ledger.jsonl") as f:
    for line in f:
        record = json.loads(line)
        print(record["task_id"], record["amount_usd"], record["status"])

The ledger is your source of truth. It tells you which function earned, how many calls settled, and which were refunded on failure. That visibility is what turns an endpoint into something you can measure.

What Determines Your Actual Revenue

The tollbooth handles collection. It does not create demand. Whether this turns into meaningful API revenue depends on factors you control: how much agent traffic reaches your endpoint, how you price relative to the value delivered, and how reliable the function is under load. A widely-called function at a fair pay per call price has potential. A function nobody calls earns nothing regardless of the billing layer.

This is informational and not financial advice. Any numbers here are illustrative and do not represent expected or typical earnings. Model your own scenario against your own traffic. The deeper mechanics of decorator-based billing and agent-facing pricing are covered in the linked posts below.