Togai MCP for AI. Manage Usage, Billing, and Entitlements in Conversation
Gemini Works with every AI agent you already use
…and any MCP-compatible client
How this MCP server connects to your AI agent
Togai handles usage-based billing and metering right through your AI agent. It ingests raw event data, manages customer accounts, defines complex pricing models via rate cards, and instantly checks entitlements.
Your agent can check wallet balances, list invoices, or grant credits without leaving the chat window.
What AI agents can do with Togai (Usage Metering & Pricing) Automation
Check entitlement
Checks if a customer has access to a specific feature based on their plan.
Create account
Creates a new, dedicated billing account within the system.
Create customer
Sets up a new legal entity record for billing purposes.
Send single (ingest_event) or bulk batches of raw usage data to record consumption.
Create, read, and update customer records and dedicated billing accounts for tracking revenue.
Set up how raw events are converted into billable metrics using usage meters and price plans.
Retrieve invoice lists, check current wallet balances, or manually apply credits to an account.
Verify if a customer has access to a specific feature and what their remaining usage limits are.
Ask an AI about this
Waiting for input…
What AI agents can do with Togai (Usage Metering & Pricing) MCP Server: 19 Tools for Billing
These tools let your agent manage billing cycles end-to-end—from ingesting usage events to listing invoices and checking feature entitlements.
Make your AI actually useful.
Add this MCP to Claude, Cursor, or Windsurf and your AI stops guessing. It gets real tools to look things up, take action, and handle the stuff you keep doing by hand.
Start using Togai (Usage Metering & Pricing) on VinkiusCheck Entitlement
Checks if a customer has access to a specific feature based on their plan.
Create Account
Creates a new, dedicated billing account within the system.
Create Customer
Sets up a new legal entity record for billing purposes.
Create Price Plan
Defines and creates a new pricing structure (V2) that determines costs.
Create Usage Meter
Establishes how raw usage data must be aggregated to become billable units...
Get Account
Retrieves all financial details for a specific billing account ID.
Get Customer
Retrieves the profile and metadata for a specific customer entity.
Get Entitlements
Fetches all current feature access rights and usage limits tied to an account.
Get Metrics
Pulls aggregated, calculated metrics across specified time ranges for reporting.
Get Wallet Balance
Returns the current available credit balance held by a billing account.
Grant Credit
Manually adds credits to an existing account's wallet balance.
Ingest Batch Events
Accepts and processes a large batch of usage events simultaneously for bulk ingestion.
Ingest Event
Sends a single, detailed usage event object to record consumption in real-time.
List Accounts
Retrieves a list of all billing accounts managed under the system.
List Customers
Provides a list of all customer entities registered in the system.
List Invoices
Retrieves a paginated list of generated invoices, allowing filtering by date or...
List Rate Cards
Shows all defined rate cards associated with a specific price plan for review.
Update Account
Modifies existing details on an active billing account, like contact info or status.
Update Customer
Updates non-billing profile information for a customer entity.
Security and governance baked right in.
Pick your AI client below to get set up. Just create a Vinkius account, subscribe, and you're instantly up and running. We handle the entire backend infrastructure, delivering out-of-the-box support for HTTPS Streamable, SSE, and OAuth2—zero messy routing required.
Claude AI
Open Claude Settings
Go to claude.ai, click your profile icon, then navigate to Customize → Connectors.
Add Custom Connector
Click the "+" button and select Add custom connector. Paste your Vinkius endpoint URL:
https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp
Replace [YOUR_TOKEN_HERE] with your token
from cloud.vinkius.com. For OAuth-protected servers, expand
Advanced settings to add credentials.
Start a conversation
Open a new chat. The Togai integration is available immediately — no restart needed.
Choose How to Get Started
Build a custom MCP for your own tools, or connect a ready-made integration from our catalog.
Build Your Own
Turn any API into an MCP. Import a spec, define Agent Skills, or deploy with MCPFusion.
- Import from OpenAPI, Swagger, or YAML specs
- Create Agent Skills with progressive disclosure
- Deploy to edge with MCPFusion framework
- Built in DLP, auth, and compliance on every call
- Real time usage dashboard and cost metering
- Publish to catalog or keep private
Make Your AI Do More
Start with Togai (Usage Metering & Pricing), then connect any of our 5,100+ other servers whenever your AI needs more. One click, no limits.
- Use this MCP plus 5,100+ others, all in one place
- Add new capabilities to your AI anytime you want
- Every connection is secured and compliant automatically
- Track usage and costs across all your servers
- Works with Claude, ChatGPT, Cursor, and more
- New servers added to the catalog every week
Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by Togai. All third-party trademarks, logos, and brand names are the property of their respective owners. Their use on this website is strictly for informational purposes to identify service compatibility and interoperability.
VINKIUS INFRASTRUCTURE
Cloud Hosted
Managed infra
V8 Isolated
Sandboxed per request
Zero-Trust Proxy
No stored credentials
DLP Enforced
Policy on every call
GDPR Compliant
EU data residency
Token Compression
~60% cost reduction
Built on the Model Context Protocol (MCP) for Claude, ChatGPT, Cursor, and more
The Model Context Protocol standardizes how applications expose capabilities to LLMs. Instead of operating in isolation, your AI gains direct access to external platforms, live data, and real-world actions through secure, standardized connections.
This connection provides 19 powerful capabilities that interface natively with Claude, ChatGPT, Cursor, and other compatible AI platforms. No middleware. No custom integration required.
Manual Billing Reconciliation Takes Hours, Solved with Vinkius AI Gateway
Today, reconciling usage across departments means exporting data from the event log, dumping it into a spreadsheet, and manually matching those records against invoice IDs. You spend half your day copy-pasting numbers between tabs just to verify if the customer was billed correctly for 50 API calls.
With this MCP server, you tell your agent: 'Show me all usage events from last month that resulted in an invoice.' Your agent runs `get_metrics` and pulls data directly against `list_invoices`. The whole audit happens instantly in the chat window.
Togai (Usage Metering & Pricing) MCP Server
The biggest headache is setting up the logic itself. You have to define how '10,000 requests' translates into '$50'. This requires creating a usage meter and linking it to a price plan manually.
Here’s the difference: you run `create_usage_meter` and link it via your agent prompt. The system handles the complex mapping logic—the raw event object becomes an auditable, billable unit without leaving your workflow.
What your AI can actually do with this
Togai handles all usage-based billing right through your AI agent. Your agent ingests raw event data, manages customer accounts, defines complex pricing models using rate cards, and instantly checks entitlements—all without leaving the chat window.
Tracking Usage Events. You can send single use events using ingest_event, or you'll process large volumes of usage data at once with ingest_batch_events. To pull aggregated metrics for reporting across specific time ranges, your agent calls get_metrics.
Setting Up Customers and Accounts. When a new client comes in, you can use create_customer to set up their legal entity record. You'll establish the dedicated billing side of things by running create_account, and if those details change later, your agent uses update_account. To keep the customer profile current without touching billing details, it runs update_customer.
If you need a full picture of all accounts managed in the system, call list_accounts; to see every registered client, use list_customers.
Defining Billing Logic and Pricing. To make sure raw usage data translates into actual dollars, your agent first creates how that aggregation must happen by calling create_usage_meter. This tool requires you to specify the event type and computation rules for billable units. Next, you define what those billable units cost using create_price_plan, which sets up a whole pricing structure (V2).
For review, your agent can pull every defined rate card tied to a price plan by calling list_rate_cards. If you need specific financial details for an existing account, you'll use get_account; to check the basic profile and metadata of any customer, run get_customer.
Controlling Access and Features. Your agent checks if a user can access a feature by calling check_entitlement, which verifies access based on their current plan. For a complete view of all usage limits and feature rights tied to an account, you'll use get_entitlements. If the client needs more credits in their wallet, your agent manually adds them using grant_credit; they can also check how much credit is available right now by calling get_wallet_balance.
Auditing and Reviewing Finances. To see a full history of charges, your agent pulls a paginated list of generated invoices using list_invoices, allowing you to filter that data by date or status. If you need all the current financial details for an account, you'll use get_account. You can pull detailed usage metrics across timeframes with get_metrics.
Your agent also handles necessary setup tools: it runs create_price_plan to define new cost structures; and while you might get a list of all customers using list_customers, your agent uses specific functions like create_customer or update_customer when the data actually needs changing. You can retrieve the full details for any known account ID with get_account; and if you need to verify current feature access, it calls check_entitlement.
The server exposes a complete set of tools that lets your agent manage everything from raw event ingestion to final invoice review.
019e5d60-fc29-73d7-a5b4-b2e2ff6ce36b 
Here's how it actually works
The bottom line is: you use your AI client to talk to the API directly, making complex billing operations feel like simple conversation.
First, subscribe your AI client to the Togai server and provide your required API Key.
Next, use tools like create_customer or create_account to set up the billing structure for a new user or product line.
Finally, run commands like ingest_event or check_entitlement. Your agent sends the request, Togai processes it against your defined pricing rules, and you get back real-time financial status.
Who is this actually for?
Product Managers who need to validate pricing models before deployment. FinOps engineers tired of jumping between dashboards to reconcile usage data and invoices. Developers building SaaS platforms that require immediate, accurate metering logic.
Manages the full lifecycle: creating new price plans (create_price_plan), listing existing customers, and ensuring correct billing data is ingested.
Verifies customer usage limits and feature access by running check_entitlement to confirm product rollout rules are followed. Also uses get_metrics for high-level reporting.
Tests event pipelines by sending raw data via ingest_batch_events, and verifies account status using list_accounts or get_account.
What Changes When You Connect
Automate revenue reconciliation. Instead of exporting data to a spreadsheet, ask your agent to list_invoices or get_wallet_balance directly from the chat.
Handle usage spikes instantly. Use ingest_event or ingest_batch_events to push raw consumption data and update billing records in real-time.
Control product access granularly. Check a user's current limits using get_entitlements before allowing them to use a premium feature, preventing overages.
Simplify account setup. Your agent can create both the customer profile (create_customer) and the billing structure (create_account) in two steps.
Adjust finances on the fly. Need to fix an error? Use grant_credit to apply credits directly, logging the action without touching a GUI.
See it in action
Onboarding a New Partner
A new enterprise partner signs up. Your agent first runs create_customer and then uses create_account to establish their billing record. Next, it calls create_price_plan to define the tiered rates, completing the setup in minutes.
Auditing Overages
A customer claims they were overcharged for API requests. Instead of manually digging through logs, your agent runs get_metrics and cross-references it with list_invoices to quickly pinpoint the exact usage period causing the discrepancy.
Feature Rollout Testing
A Product Manager wants to test a limited beta feature. The agent calls check_entitlement with specific parameters, confirming that only users assigned the correct entitlement can access the new tool endpoint.
Processing Daily Usage Data
At midnight, your background job doesn't run a dashboard report. It sends all raw logs to ingest_batch_events, which automatically triggers the logic defined by create_usage_meter and updates the active account balance.
The honest tradeoffs
Using spreadsheets for billing
Attempting to calculate prorations or manage usage thresholds by manually updating CSV files. This fails when volume grows or pricing changes.
Use create_usage_meter and get_metrics. Define the computation rules once, then let your agent call get_metrics to get accurate, system-calculated numbers.
Ignoring account status
Allowing a customer to use premium features even if their wallet balance is zero. This leads to service disruption and poor UX.
Always check the financial state first. Call get_wallet_balance before running any action that consumes credits, or use check_entitlement.
Over-updating customer data
Running update_customer for every minor change (e.g., fixing a typo). This creates unnecessary API calls and potential conflicts.
Use get_customer first to verify the current state, then run update_customer only when necessary changes are confirmed.
When It Fits, When It Doesn't
Use this server if your core problem is tracking usage-based revenue. Specifically, you need tools that bridge raw data (events) and financial outcomes (invoices/credits). The key path is: create_customer -> create_price_plan -> create_usage_meter -> ingest_event. Don't use this if you simply need a notification system; those are messaging tools. You also don't need it if your only task is pure payment processing (like connecting to Stripe); for that, you need a dedicated payment gateway toolset, not just billing logic.
Questions you might have
How do I check if a user can access a premium feature using check_entitlement? +
The check_entitlement tool validates feature access instantly. You pass the specific feature ID, and it returns true or false based on their current account limits.
Can I list all invoices and filter them by date using list_invoices? +
Yes, list_invoices supports optional filters. You can narrow down the results to specific date ranges or status types right in your prompt.
What is the difference between get_metrics and ingest_event? +
ingest_event pushes new, raw data into the system. get_metrics pulls calculated totals—it shows you what has been processed and aggregated for reporting.
How do I make a payment adjustment using grant_credit? +
Use the grant_credit tool, specifying the target account ID and the credit amount. This action logs the credit application directly to the customer's wallet balance.
What data schema does the `ingest_event` tool require for usage tracking? +
The ingest_event tool requires an event object containing a schemaName, timestamp, accountId, and at minimum attributes. You must provide these fields to ensure accurate record keeping and proper billing attribution.
Should I use `get_metrics` or `ingest_batch_events` for large amounts of historical data? +
Use ingest_batch_events. This tool is designed to process many usage records at once, which is vastly more efficient than calling single-event APIs. It handles the volume required for bulk history ingestion.
If a customer changes their legal name or address, should I use `update_customer`? +
Yes, you use update_customer. This function modifies existing records rather than creating duplicates. It's the proper way to maintain clean data while reflecting necessary business changes.
What happens if my API key lacks permissions when I call `get_wallet_balance`? +
The call will return an authorization error, indicating insufficient scope. You'll need to check your server credentials and ensure the associated API key has read access to financial data.
How do I verify if a customer has access to a specific feature? +
You can use the check_entitlement tool by providing the account ID and the feature ID. The agent will return whether the customer is entitled to use that feature based on their current plan.
Can I check the remaining credit balance for a specific account? +
Yes, use the get_wallet_balance tool with the target account ID. It will retrieve the current balance, including any granted credits or prepaid amounts.
Is it possible to list all invoices for a customer to check payment status? +
Absolutely. Use the list_invoices tool. You can filter or browse through the generated invoices to see which ones are paid, pending, or overdue.
We've already built the connector for Togai. Just plug in your AI agents and start using Vinkius.
No hosting. No infrastructure. No complex setup.
All 19 tools are live and waiting.
You're up and running in seconds.
Gemini Vinkius gives your AI agents access to the full catalog of app connectors, all fully managed, secure, and enterprise-ready. One subscription, every tool you need.
Built, hosted, and secured by Vinkius. You just connect and go.