​
What is AgentPay?

As AI agents and the Model Context Protocol (MCP) ecosystem grow, developers need a frictionless way to charge for usage, and users need a seamless way to pay. AgentPay is the payments layer for MCP Servers, purpose-built for the agent economy. It integrates with the latest MCP standards and tooling, making it effortless for MCP Developers to monetize and for MCP Users to connect and pay.
AgentPay is currently in Early Access. To get early access to AgentPay, please sign up for the Waitlist here.

​
Familiar Payments for a New Ecosystem

Before we delve into the architecture of how it works, let’s simplify the core concept.

Typical AI Service

Imagine the way you currently interact with many modern AI services (like OpenAI, Anthropic, or various cloud APIs). You typically sign up, get an API key, and preload a balance. Your API key then grants you access, and you’re billed against your balance based on your usage. AgentPay brings this familiar, battle-tested model to the world of MCP Servers.
  • For MCP Users ⎯ It’s like having a universal access pass:
    • You maintain an AgentPay account with a single balance.
    • When you want to use a specific MCP Server that’s integrated with AgentPay, you obtain a unique API Key for that server.
    • You then add your API Key to your MCP client configuration (e.g. Claude, Cursor) to use this key to make requests.
    • If the tool has a cost, AgentPay seamlessly deducts it from your balance upon successful use.
    • No complex per-server payment setups, just straightforward, metered access.
  • For MCP Developers ⎯ It’s your turnkey monetization solution:
    • You’ve built valuable features ⎯ tools, resources, prompts, and more ⎯ on your MCP Server.
    • By integrating AgentPay, you can define a price for each usage of each feature, and start earning immediately.
    • When an authenticated user (with a valid API Key and sufficient balance) successfully uses a feature, AgentPay handles the balance transfer to your earnings, which are then paid out to you.
    • No need to build and maintain your own complex infrastructure for payments, API, or metering, just one simple, flexible integration.
At its heart, AgentPay establishes a clear, trusted, and standardized “pay-as-you-go” relationship between MCP Users and MCP Server Developers, all facilitated by API keys and managed balances, and built to conform with MCP standards. This allows developers to focus on building great tools and users to access them with ease and transparency.

​
How does it work?

AgentPay provides a standardized, end-to-end solution for MCP Servers to manage access and bill for usage from MCP Clients. It provides API Keys for Users and Service Tokens for Developers, allowing AgentPay to:
  • Authenticate requests from MCP Clients to MCP Servers.
  • Track usage of MCP Server resources.
  • Handle payments, like user balances and developer payouts.
Generally speaking, there are three key aspects to understand:

​
1. Setup: Acquiring Tokens and Keys

In order to use or monetize MCP Servers, Developers and Users must first hop on AgentPay Hub to get their respective credentials.
  • AgentPay Hub ⎯ The central AgentPay web platform where:
    • MCP Developers register their MCP Servers, obtain Service Tokens, manage Server metadata, view revenue dashboards, and configure payouts.
    • MCP Users discover MCP Servers, obtain API Keys, and manage their account balance.
  • MCP Developer ⎯ Developer of the MCP Server who:
    • Registers their MCP Server on AgentPay Hub.
    • Receives a Service Token, which uniquely identifies their server and authenticates its requests to the AgentPay Service (e.g., when reporting usage).
    • Integrates the AgentPay SDK in their MCP Server using their Service Token.
  • MCP User ⎯ User of an MCP Server via an MCP Client who:
    • Activates an MCP Server they want to access via AgentPay Hub.
    • Obtains an API Key for that server, which identifies the user and is used to authorize their requests and track their balance.
    • Adds the API Key to their MCP Client configuration.

​
2. Runtime: Processing MCP Requests

Once setup is complete, here’s how a typical interaction unfolds when an MCP Client makes a request to an MCP Server:
  • MCP Client (with API Key configured) ⎯ When called by the User or Agent:
    • Makes a request to the remote MCP Server.
    • Sends the User’s API Key to the target MCP Server as part of the request (typically in a header).
  • MCP Server (with AgentPay SDK integrated) ⎯ Upon receiving a request:
    • Extracts the User’s API Key (e.g. using AgentPay SDK auth helpers).
    • (Optionally) Validates the API Key via the AgentPay Service.
    • Processes the client’s request (executes its core tool logic).
    • If the tool logic is successful, it consumes the User’s balance via the AgentPay Service (using the SDK, the User’s API Key, and its own Service Token) for an agreed amount_cents.
  • AgentPay Service (via the AgentPay SDK) ⎯ The core AgentPay backend service which:
    • Validates API Keys and Service Tokens.
    • Processes usage requests by debiting the user’s balance and crediting the developer’s earnings.
    • Manages the ledger for all balances and transactions.

​
3. Payment: The Flow of Funds

AgentPay facilitates a direct and transparent flow of funds, enabling users to pay for services and developers to earn revenue.
The process unfolds in these key stages:
  • MCP User Funds AgentPay Balance:
    • MCP Users add funds to their AgentPay account, establishing a balance to pay for MCP Server usage.
  • Tool Consumption & Charging:
    • When an MCP User’s client successfully uses a paid feature (tool, resource, etc.) on an MCP Server:
      • The MCP Server, after its own logic succeeds, triggers a charge using the AgentPay SDK.
      • This involves the User’s API Key (identifying the payer) and the Developer’s Service Token (identifying the payee).
  • Transaction Processing by AgentPay:
    • AgentPay validates the transaction details (API Key, Service Token, sufficient funds).
    • The specified amount (amount_cents) is deducted from the User’s balance.
    • The corresponding amount (less any AgentPay service fees) is credited to the MCP Developer’s earnings ledger within AgentPay.
  • MCP Developer Payouts:
    • MCP Developers can view their accumulated earnings on AgentPay Hub.
    • Earnings are typically paid out monthly.
    • Developers configure their preferred payout method (e.g., Stripe Connect for bank transfers, or supported stablecoins).
And that’s it! Now you have a complete overview of AgentPay and can start diving deeper into the growing ecosystem of premium MCP Servers.

​
Get started

AgentPay is currently in Early Access. To get early access to AgentPay, please sign up for the Waitlist here.
Jump right in with the appropriate Quickstart for you.

​
Quickstarts

MCP Server Developers

For developers looking to integrate AgentPay into their MCP Server.

MCP Client Users

For users who want to use MCP Servers that have AgentPay integrated.