What monetizing a crew means

Monetizing a CrewAI crew means charging callers for the work the crew produces, settled in USDC on Base, per call. The crew already does something valuable, a research brief, a generated asset, an analysis, and monetizing it is putting a price in front of that output so a caller pays before the crew runs. The crew itself does not change; you add a paywall ahead of it.

This is the earn side of CrewAI. The spend side, agents paying for what they call, is crewai-wallet-tool; the broad integration reference is crewai-payment-integration; the general monetization decisions are how-to-monetize-ai-agent. Here the focus is the CrewAI-specific path to charging, which has one wrinkle worth understanding first. The payment API product page is the broader reference.

The Node gateway pattern

Here is the wrinkle: the x402 server adapter ships for Node (Fastify and Express), and CrewAI runs in Python, usually behind a web framework like FastAPI. So you do not gate the crew from inside Python; you front it with a small Node gateway.

The gateway is a tiny Fastify (or Express) service that mounts createX402Plugin, returns the 402, verifies payment, and proxies paid requests to your Python crew endpoint. Your crew stays exactly as it is, serving its result on its own HTTP route; the gateway sits in front and is the only thing that knows about payment. This is the same front-with-a-gateway approach any non-Node stack uses to speak x402, and for a CrewAI crew it is the clean, honest path that keeps every payment identifier on the verified Node surface.

Gate the crew endpoint

The gateway gates the route and proxies paid traffic to the crew.

import Fastify from "fastify";
import { createClient } from "@blockchain0x/node";
import { createX402Plugin } from "@blockchain0x/x402/server/fastify";

const sdk = createClient({ apiKey: process.env.B0X_API_KEY! });
const app = Fastify();

await app.register(createX402Plugin, {
  sdk,
  defaultNetwork: "testnet",
  pricing: {
    "POST /crew/run": { amountUsdc: "0.25", payToAddress: process.env.B0X_PAYTO_ADDRESS!, paymentRequestId: "pr_crew" },
  },
});

// Paid requests reach here; proxy them to the Python crew service.
app.post("/crew/run", async (req) => {
  const r = await fetch("http://127.0.0.1:8000/run", { method: "POST", body: JSON.stringify(req.body) });
  return await r.json();
});

await app.listen({ port: 8080 });

An unpaid POST /crew/run gets a 402 quoting the price; the adapter verifies the X-Payment header through paymentRequests.settle on the retry; only then does the gateway call your Python crew at :8000 and return its result. The crew never sees the payment, and you did not touch its code.

What to charge for

Charge for the crew's output, not its mechanics, and price per the value of a run. A crew that produces a finished research report is one paid call for that report; a caller pays once and gets the deliverable. Resist gating per internal tool call or per agent step, which the caller neither sees nor cares about; they are buying the result, so price the result.

Keep discovery free. A route that lists what the crew does, what inputs it takes, and what it returns belongs on an unpriced path, so a caller (often another agent) can evaluate the crew before paying. Set the price from the crew's real cost (the upstream APIs and model calls a run consumes) plus a margin, then adjust on conversion data. The general pricing strategy is in how-to-monetize-ai-agent; the CrewAI-specific point is to price the run, keep discovery open, and let the gateway enforce it.

Keep a free discovery route

A paid crew that gives a caller no way to see what it does before paying will not get called, especially by machine callers that evaluate options programmatically. So pair every gated route with a free one. Leave a GET /crew/describe route off the gateway's pricing map (or serve it from the crew directly) that returns the crew's purpose, the inputs it expects, and the shape of what it returns. A caller, often another agent, reads that, decides the crew is worth the price, and then pays the gated POST /crew/run.

This mirrors how the pay side reasons: the crewai-wallet-tool lets a calling agent weigh a price before spending, and a free discovery route is what gives it something to weigh. Discovery free, work paid is the shape that makes an agent-to-agent economy actually transact, because both sides can evaluate before money moves.

Verify a paid run end to end

Before charging real callers, prove the loop on Base Sepolia. Call the gated route with no payment and confirm a 402 comes back quoting your price in USDC. Then call it through a paying client (the x402 client, or another agent's wallet tool) and confirm three things: the payment settles, the gateway proxies the request to your crew, and the crew's result comes back to the caller. Watch the dashboard for the matching settlement on the crew's agent profile, which is where the USDC lands.

That single end-to-end check, unpaid gets a 402 and paid runs the crew, is the whole contract. Once it holds on testnet, swapping the gateway's sk_test_ key for an sk_live_ key moves the same flow to Base mainnet with no other change, since the network is read from the key prefix.

Compatibility

The gateway sits in front, so it works regardless of how the crew is served.

When this fits

Monetizing a crew fits when the crew produces output worth paying for and you want machine callers, other agents, apps, to pay per use with no signup. The Node-gateway path fits any Python crew, which is most of them, and adds one small process rather than a rewrite.

It fits less well when the crew is internal-only (no external caller to charge) or when a human buyer wants a contract and an invoice (a traditional checkout suits that better). For an agent-facing crew that sells a result, the gateway plus per-call USDC is the path that reaches callers a signup funnel never would.

Pricing

Monetizing is free to set up; you pay the wallet platform fee per agent profile on the pricing page: Free is $0 per agent per month at a 5% transaction fee, Pro is $9 at 2%, Business is $29 at 1%. The fee applies to the crew's own agent profile, the one that receives the USDC, and scales with what you earn rather than a flat seat.

What to ship today

Stand up a small Node gateway with createX402Plugin in front of your crew's HTTP endpoint, price one route, and confirm an unpaid call gets a 402 while a paid one runs the crew and returns its result on Base Sepolia. Keep a free discovery route. For the broad integration overview see crewai-payment-integration. Pricing is on the pricing page.