Polar.sh MCP for AI. Manage your entire monetization lifecycle from chat.
Works with every AI agent you already use
…and any MCP-compatible client








Connect to your AI in seconds.
Polar.sh MCP Server manages your open-source monetization and SaaS billing cycle directly through your AI agent. Use it to list products, create subscriptions, track orders, and generate invoices—all from natural language commands in your terminal or editor.
It handles the full customer lifecycle, allowing you to manage everything from initial checkout sessions (`create_checkout`) to revoking access when a subscription expires (`revoke_subscription`).
What your AI can do
Confirm checkout client
Confirms the status of a specific checkout session from the client side.
Create benefit
Creates a new, defined product benefit for customers.
Create checkout
Initiates and creates a new checkout session record.
Create new digital goods and update existing product details using create_product and update_product.
Retrieve full order details with get_order and generate a ready-to-use invoice document via generate_invoice.
List all customers (list_customers) and view their complete subscription status, including active benefits, using get_customer_state.
Grant or revoke access by creating new subscriptions (create_subscription) or immediately canceling an existing one with revoke_subscription.
Inspect recent checkout sessions using list_checkouts to pinpoint where users drop off during the purchase process.
Ask an AI about this
Waiting for input…
Polar.sh: 36 Tools for Billing & Monetization
Use these tools to manage every part of your SaaS or open-source monetization flow, from product creation and customer onboarding to subscription management and invoicing.
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 Polar.sh on VinkiusConfirm Checkout Client
Confirms the status of a specific checkout session from the client side.
Create Benefit
Creates a new, defined product benefit for customers.
Create Checkout
Initiates and creates a new checkout session record.
Create Customer Session
Generates a unique token needed for a customer to start a secure session.
Create Customer
Adds a brand-new customer account to the billing system.
Create Product
Creates and registers a new marketable product or digital good.
Create Subscription
Sets up a new subscription, limited only to free products initially.
Create Webhook Endpoint
Registers a custom URL endpoint where the system sends automated updates.
Delete Benefit
Removes an existing product benefit, which also revokes all associated user grants.
Generate Invoice
Creates and outputs a professional invoice file for a specific order ID.
Get Benefit
Retrieves the detailed information about a specific product benefit.
Get Checkout
Pulls all data related to a specific checkout session record.
Get Customer State
Gets a full overview of a customer's active subscriptions and granted benefits in one call.
Get Invoice
Retrieves the raw, structured data for a previously generated invoice.
Get Order
Fetches all details about an order placed by a customer.
Get Portal Me
Gets basic profile information for the currently authenticated user making the...
Get Product
Retrieves detailed metadata about a specific product ID.
Get Subscription
Fetches the full status and billing details of an active subscription.
List Benefits
Lists all available, defined benefits in your product catalog.
List Checkouts
Provides a summary list of recent checkout sessions for review.
List Customers
Returns a filterable list of all registered customer accounts.
List Orders
Lists historical order records, allowing filtering by date or status.
List Portal Benefit Grants
Shows every benefit that has been explicitly granted to a specific customer.
List Portal License Keys
Provides a list of all license keys associated with customer accounts.
List Portal Orders
Lists all historical orders tied specifically to a single customer ID.
List Portal Subscriptions
Shows all subscription records for a specific customer account.
List Products
Queries and filters your entire product catalog by various criteria.
List Subscriptions
Lists active or past subscriptions across the whole platform.
List Webhook Deliveries
Monitors and lists all webhook messages that were delivered (or failed to deliver).
Revoke Subscription
Immediately cancels a subscription, terminating customer access instantly.
Update Checkout
Modifies details on an existing checkout session before finalization.
Update Order
Changes billing or shipping details for a historical order record.
Update Product Benefits
Adjusts which benefits are tied to a specific product offering.
Update Product
Updates the core metadata (like name or price) of an existing product.
Update Subscription
Update a subscription
Validate Portal License Key
Validate a license key
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.
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 Polar.sh, 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 Polar.sh. 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
Works with 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 36 powerful capabilities that interface natively with Claude, ChatGPT, Cursor, and other compatible AI platforms. No middleware. No custom integration required.
Running billing checks shouldn't feel like navigating 12 different dashboards.
Today, handling a basic customer inquiry is a nightmare. You have to jump from the CRM dashboard (to check status) over to the invoicing portal (to find past orders), and finally into the product management system (to see what benefits they actually own). It's copy-pasting IDs between three different tabs just to get an answer.
With this MCP server, you tell your agent: 'What is customer X paying for and when does it expire?' The agent runs `get_customer_state` and pulls the entire status—subscriptions, benefits, and order history—into one clean data dump. You get the answer immediately.
Polar.sh MCP Server: Manage product monetization with precision.
Manual benefit management involves defining a feature in one place, linking it to a price tier in another, and then manually granting that link to the user in a third system. If any step fails, the customer just gets 'limited access' and you spend an hour debugging where the break happened.
Now, you define everything—products (`create_product`), benefits (`create_benefit`), and pricing rules—using API calls. When you run `update_product_benefits`, the system instantly updates all linked records. The complexity is handled by the server; you just manage the inputs.
What your AI can actually do with this
Listen up. Polar.sh handles your whole open-source monetization stack—the billing, the subscriptions, the product catalog—and it runs it all straight through your AI agent. You don't gotta switch apps or leave your terminal; you just tell your agent what to do in natural language and it executes the API calls for you.
Managing Your Product Catalog:
When you need to sell something, you start by creating it. You use create_product to register any new digital good. If an existing product needs a name change or a price tweak, you run update_product. To define what the customer actually gets, you create specific benefits using create_benefit, and if that benefit is scrapped, running delete_benefit removes it and revokes every associated user grant.
You can see all the perks customers buy into by checking list_benefits, or get the deep details on one perk using get_benefit. When you link a benefit to a product, you adjust those ties with update_product_benefits.
Handling Customers and Accounts:
Setting up users is simple. You use create_customer to add a new account to the billing system. Before a customer can do anything secure, your agent first generates a unique token using create_customer_session. To check on any user's current standing—what they’re subscribed to and what benefits they’ve got—you run get_customer_state.
For a full rundown of all registered accounts, you can pull a filterable list with list_customers. If you need to see every single benefit granted to one specific customer, list_portal_benefit_grants shows it. To check which license keys are out there for an account, run list_portal_license_keys. You can also view all historical orders tied to a single ID using list_portal_orders, or see every subscription record for that user with list_portal_subscriptions.
Subscriptions and Access Control:
If you want to give someone access, you use create_subscription, which initially restricts free product setups. To track what’s going on with a specific paid service, run get_subscription. If the customer loses their right to access, calling revoke_subscription instantly terminates their account privileges. You can also update an existing subscription record using update_subscription.
When you need to check if a license key is legit before giving access, use validate_portal_license_key. For general oversight of all paid services, list_subscriptions pulls the records, and checking recent user activity comes through list_checkouts, which gives you a summary list of attempted purchases.
Billing, Orders, and Funnel Analysis:
When it's time to get paid, your agent can initiate a purchase by running create_checkout, or modify details on an existing cart using update_checkout. Once the process is done, you check the status of that checkout with confirm_checkout_client or pull all data related to it using get_checkout.
To see a customer's past purchases, use get_order, and for a summary list of historical orders across the board, run list_orders, which lets you filter by date or status. When an order is finalized, running generate_invoice creates a professional invoice file for that specific order ID. You can also retrieve the raw data for any past billing with get_invoice.
If an order needs its details tweaked—say, the shipping address changed—you use update_order. For tracking how people drop off during checkout, you monitor list_checkouts. Finally, if your system sends automated updates to a custom endpoint, you first register that URL using create_webhook_endpoint, and then track the status of those messages with list_webhook_deliveries.
019ea5ff-64b5-708a-b618-133c6d0e5e08 Here's how it actually works
The bottom line is that your agent acts as a universal billing terminal, running complex multi-step API sequences based on simple natural language prompts.
Subscribe to this server and provide your Polar Personal Access Token.
Reference a specific business action (e.g., 'Generate an invoice for order X').
Your AI client calls the necessary tool(s) (like get_order followed by generate_invoice), and you get the resulting data or confirmation.
Who is this actually for?
Anyone who runs revenue generation and needs to interact with billing systems but hates leaving their code editor or terminal. This is for the developer who has too many dashboards to check, the founder who needs instant MRR visibility, and the dev relations person tasked with managing community benefits.
Manages sponsorships and digital products by calling list_products or issuing free access via create_subscription without needing a web dashboard.
Checks Monthly Recurring Revenue (MRR) status using tools like get_customer_state, processes urgent orders, and handles billing issues immediately.
Investigates customer account problems by running get_order or verifying subscription access with get_benefit to quickly resolve support tickets.
What Changes When You Connect
Process billing actions instantly: Instead of jumping between the Polar dashboard and a ticketing system, you run get_order and then immediately follow up with generate_invoice—all through your agent's prompt. You get the final invoice data in seconds.
Maintain customer history cleanly: Use tools like list_customers and get_customer_state to pull a single, unified profile view of any user. This means you see their active subscriptions (list_portal_subscriptions) alongside all benefits they've ever been granted.
Manage access control precisely: You can grant or revoke product access on the fly. Need to disable a former client? Call revoke_subscription and confirm termination instantly, without touching a web portal.
Build complex workflows easily: The ability to chain calls—like checking out first (create_checkout), updating details (update_checkout), and then confirming it all in one prompt—makes multi-step billing tasks feel like single commands.
Keep your product catalog accurate: Don't manually edit prices. Use list_products to see everything, and use update_product or create_benefit when pricing tiers change. The data stays source-of-truth compliant.
See it in action
Customer needs a refund/adjustment.
A client calls in saying their last invoice was wrong. Instead of digging through email archives, your agent runs get_order to verify the original purchase. Then, using update_order, it adjusts the billing details and creates a corrected record, resolving the issue in one conversational turn.
New open-source project launch.
You just finished building a new digital good. You use create_product to register it, then call create_benefit to define how users access it, and finally set up the payment structure with update_product_benefits. It's done before lunch.
Handling a trial-to-paid upgrade.
A free user is ready to pay. Your agent first calls create_customer if they don't exist, then runs create_checkout to start the process. Finally, it validates and completes the purchase flow using confirm_checkout_client, getting them active billing status.
Mass account cleanup after a merger.
You need to audit 50 old accounts for compliance. Your agent iterates through list_portal_subscriptions and runs get_customer_state on each one, giving you an immediate spreadsheet-ready report of who is paying and who needs access revoked.
The honest tradeoffs
Updating billing details manually.
Going into the old web dashboard to change a customer's tax ID or name, only for the data to get out of sync with your internal records. This is slow and error-prone.
Use update_order directly through your AI agent. You tell it: 'Update order XYZ with new billing details,' and it handles the API call correctly.
Assuming a single read gets all history.
Calling get_product once, thinking you know everything about its pricing and benefits, only to find out key benefit grants are missing from your view. The data is incomplete.
Always check the full picture by calling list_portal_benefit_grants or running a comprehensive check with get_customer_state. Don't trust one single API call.
Forgetting to finalize a session.
A customer starts a checkout process using create_checkout, but then gets distracted. The session hangs, and you have no way of knowing if it failed or is still open.
Before concluding any purchase flow, always call get_checkout with the ID to verify its current status. If it's stalled, use update_checkout.
When It Fits, When It Doesn't
Use this server if your workflow involves multiple, interconnected billing steps that require real-time data access: checking customer state, creating products, and generating invoices. The key is managing the transition of ownership—from a free trial to a paying subscriber. Don't use it if you only need simple read operations (like just listing product names); those basic reads might suffice elsewhere. However, if your process requires writing data back to an external system or needs multi-step transaction integrity (e.g., 'create user -> create sub -> generate invoice'), this MCP server is the mandatory central API layer. Always validate state transitions using get_customer_state before attempting a write operation like update_subscription.
Questions you might have
How do I check a customer's total status using Polar.sh MCP Server? +
You run get_customer_state. This single call provides an overview of their active subscriptions, all granted benefits, and key billing metadata, letting you know exactly where they stand without making multiple requests.
Can I generate a refund invoice with Polar.sh MCP Server? +
Yes. You first use get_order to pull the order details, then you call generate_invoice. This creates the necessary documentation for accounting and record-keeping.
What if I need to change a product price? Do I use Polar.sh MCP Server? +
Yes, use update_product to change the core metadata like pricing. If you are changing which benefits that product offers, use update_product_benefits instead.
Is there an easy way to cancel a subscription using Polar.sh MCP Server? +
Absolutely. Use revoke_subscription. This function terminates access immediately and updates the customer's status record without needing any manual web interaction.
When should I use the Personal Access Token when calling `list_customers` via Polar.sh? +
You must provide your token during setup to authorize the connection. This security measure ensures that only you can view sensitive customer data, like what list_customers retrieves.
If I need external systems notified of changes, how do I use `create_webhook_endpoint` with Polar.sh? +
First, you create the endpoint using this tool. This tells Polar.sh exactly where to send automatic updates whenever a relevant event happens. Use the resulting URL in your system's configuration for real-time data pushes.
If a customer fails payment, how do I see the attempt using `list_checkouts` with Polar.sh? +
You run list_checkouts to pull all session records. The resulting data shows the status and failure reason for every checkout attempt. This lets you troubleshoot conversion issues before they become problems.
Can I verify which specific benefits were granted using `list_portal_benefit_grants` with Polar.sh? +
Yes, that function shows all grants linked to a customer account. It provides the exact benefit name and when it was awarded, allowing you to audit access control easily.
Can I cancel a user's subscription through the AI? +
Yes, you can use the revoke_subscription tool by providing the specific Subscription ID to terminate access immediately.
How do I generate an invoice for a specific order? +
Simply use the generate_invoice tool with the Order ID. The agent will trigger the invoice generation process on Polar.sh.
Is it possible to update the benefits of an existing product? +
Yes, the update_product_benefits tool allows you to modify the array of benefit IDs associated with any of your products.
We've already built the connector for Polar.sh. Just plug in your AI agents and start using Vinkius.
No hosting. No infrastructure. No complex setup.
All 36 tools are live and waiting.
You're up and running in seconds.
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.