Simple, scalable billing for AI Agents

Automate revenue operations for AI agents with flexible pricing and margin protection.

Dashboard displaying metrics: total agents, revenue, cost, and ROI. Sections for Sales, Support, HR, Engineering, Marketing, and Operations.

Turn agent activity into predictable revenue

Move beyond seat-based pricing to models that capture your AI's true value.

Know your margins

Track profit per-agent to spot your best workflows.

Price with confidence

Use real data to set prices that protect profitability.

Prove your ROI

Show customers the value your agents have created.

Billing & revenue automation

Automate your entire AI agent billing system

Handle complex AI agent billing without building your own system. From usage to payments, automate your entire revenue cycle.

Track agents with Signals

Benchmark your agent against human cost equivalents. Turn invisible AI work into clear business value.

Flexible pricing models

Mix seat-based, activity-based or outcome-based pricing in one contract. No billing rebuild needed.

Automated invoice generation

Generate professional invoices with usage breakdowns. Show customers exactly what value your agents created.

Revenue operations dashboard

Auto-track payments, manage overdue accounts, forecast revenue. We handle the back-office for you.

Payment processing

Charge customers via card and bank transfer.

Pricing simulator

Model revenue impact of pricing changes.

Business & payment ops

Manage customers & orders programmatically & manually.

Value receipts

Communicate time & cost savings vs human equivalent.

Introducing blocks

Reporting for your AI agent in seconds

Generate live charts, tables, and reports with AI. Drop-in to any app to show customers real value.

Blocks

Interface showing a search bar with financial queries, alongside charts and revenue data, including total revenue and revenue forecast.

Not ready to switch billing systems yet?

Get started with cost tracking, then activate our complete billing platform when you're ready to scale.

Learn more

Simple integration

The simplest billing setup for AI agents

Kickstart your integration with simple SDKs for Node.js, Python, Go and Ruby. Get started today with simple, self-serve onboarding.

Documentation

Order creation Configure pricing

import { PaidClient } from "@paid-ai/paid-node";
 
const client = new PaidClient({ token: "YOUR_TOKEN" });
 
const order = await client.orders.create({
    customerId: "cust_12345",
    billingContactId: "contact_67890", 
    name: "Acme Order",
    description: "Acme Order is an order for Acme, Inc.",
    startDate: "2025-01-01",
    endDate: "2026-01-01",
    currency: "USD",
    customerExternalId: "acme-inc"
});
 
console.log(`Created order: ${order.id}`);

from paid import Paid
 
# Initialize the client
client = Paid(token="YOUR_TOKEN")
 
# Create an order
order = client.orders.create(
    customer_id="cust_12345",
    billing_contact_id="contact_67890", 
    name="Acme Order",
    description="Acme Order is an order for Acme, Inc.",
    start_date="2025-01-01",
    end_date="2026-01-01",
    currency="USD",
    customer_external_id="acme-inc"
)
 
print(f"Created order: {order.id}")

require "paid_ruby"
 
api = Paid::Client.new(
  base_url: "https://api.example.com",
  environment: Paid::Environment::PRODUCTION,
  token: "YOUR_AUTH_TOKEN"
)
api.orders.create(
  customer_external_id: "acme-inc",
  name: "Acme Order",
  description: "Acme Order is an order for Acme, Inc.",
  start_date: "2025-01-01",
  end_date: "2026-01-01",
  currency: "USD"
)

import { PaidClient } from "@paid-ai/paid-node";
 
const client = new PaidClient({ token: "YOUR_TOKEN" });
 
await client.agents.update("agentId", {
    name: "Acme Agent (Updated)",
    agentAttributes: [{
        name: "Emails sent signal",
        active: true,
        pricing: {
            eventName: "emails_sent",
            taxable: true,
            chargeType: "USAGE",
            pricingModel: "PER_UNIT",
            billingFrequency: "MONTHLY",
            pricePoints: {
                USD: {
                    tiers: [
                        { minQuantity: 0, maxQuantity: 10, unitPrice: 100 },
                        { minQuantity: 11, maxQuantity: 100, unitPrice: 90 },
                        { minQuantity: 101, unitPrice: 80 }
                    ]
                }
            }
        }
    }]
});

from paid import Paid, AgentAttribute
 
client = Paid(token="YOUR_TOKEN")
 
client.agents.update(
    agent_id="agentId",
    name="Acme Agent (Updated)",
    agent_attributes=[
        AgentAttribute(
            name="Emails sent signal",
            active=True,
            pricing={
                "event_name": "emails_sent",
                "taxable": True,
                "charge_type": "USAGE",
                "pricing_model": "PER_UNIT",
                "billing_frequency": "MONTHLY",
                "price_points": {
                    "USD": {
                        "tiers": [
                            {"min_quantity": 0, "max_quantity": 10, "unit_price": 100},
                            {"min_quantity": 11, "max_quantity": 100, "unit_price": 90},
                            {"min_quantity": 101, "unit_price": 80}
                        ]
                    }
                }
            }
        )
    ]
)

require "paid_ruby"
 
api = Paid::Client.new(
  base_url: "https://api.example.com",
  environment: Paid::Environment::PRODUCTION,
  token: "YOUR_AUTH_TOKEN"
)
 
api.agents.update(
  agent_id: "agentId", 
  request: { 
    name: "Acme Agent (Updated)", 
    agent_attributes: [{
      name: "Emails sent signal", 
      active: true, 
      pricing: { 
        event_name: "emails_sent", 
        taxable: true, 
        charge_type: USAGE, 
        pricing_model: PER_UNIT, 
        billing_frequency: MONTHLY, 
        price_points: { 
          "USD": { 
            tiers: [
              { min_quantity: 0, max_quantity: 10, unit_price: 100 }, 
              { min_quantity: 11, max_quantity: 100, unit_price: 90 }, 
              { min_quantity: 101, unit_price: 80 }
            ] 
          } 
        } 
      } 
    }] 
  }
)

Frequently asked questions

How quickly can I implement AI agent billing?

Most customers are billing within 48 hours. Our SDKs auto-capture costs from major providers, and you can customize pricing models through our dashboard.

What pricing models work best for AI agent businesses?

We recommend starting with activity-based pricing for transparency, then adding outcome-based models as you scale. Mix approaches based on workflow complexity.

How do you track costs across different AI providers?

Our platform automatically monitors spending across OpenAI, Anthropic, Mistral, and 50+ providers through SDKs and OpenTelemetry integration.

Can I show customers their usage and value?

Yes, our Blocks feature creates embeddable dashboards that customers can view in real-time, showing exactly what your agents accomplish.

What happens if my agent costs spike unexpectedly?

You'll get instant alerts when costs exceed thresholds, plus real-time margin visibility to protect profitability automatically.

How does this integrate with my existing tech stack?

Our SDKs work with Python, Node.js, and Ruby. For advanced setups, we integrate through OpenTelemetry without disrupting your architecture.

Build agents and get paid

Understand your margins and get paid for the value your agents create.