paas-build
OfficialThis server enables AI agents to onboard businesses onto a payment platform and start accepting real payments — without a dashboard or manual forms.
Identify a Business (
identify_business): Resolve a business name, website, or free-text description into structured business information (name, what they do, website, country, and region) using live web search — use this first before onboarding a merchant.Go Live with Payments (
go_live): Create a real merchant account on UniPaaS (FCA-authorised rails) in sandbox and/or production environments, returning scoped access tokens for immediate payment acceptance. Supports individuals (instant) and companies (with KYB onboarding link), with progressive KYB and spend caps (£1,500 individual / £2,500 company).Create a Checkout Session (
create_checkout): Generate a hosted, payable checkout link for an already-onboarded vendor, specifying the environment, amount, currency, and an optional order reference.
paas.build MCP server
Let your AI agent take a business live on payments — no dashboard, no forms, no week-long review.
Most payment MCPs manage an account you already have. This one goes a level deeper: it creates the account. From Claude Code, Cursor, Windsurf or any MCP client, an agent can identify a business, open a real merchant account (sandbox and production, on FCA-authorised rails), and mint checkout tokens — in one session. Progressive KYB: live immediately with a cap, verification completes in the background. One rate: 3.9%.
Install
Set up the skill + slash commands (one command):
npx @paasbuild/mcp installThis writes a paas.build skill plus /paas-add-payments and /paas-check commands into your project (.claude/ + AGENTS.md), so your agent knows when and how to add payments. Then wire the tools:
claude mcp add paas-build -- npx -y @paasbuild/mcp(or point any MCP client at https://paas.build/mcp)
Then just say: "add payments to my app."
Related MCP server: app.wishpool/usa-payments-mcp
Check your app first (private-safe)
npx @paasbuild/mcp checkRuns locally in your repo — nothing is uploaded. Tells you if you'll hit the Stripe no-company wall or need Connect to pay out your users, and how to go live instead. Public repo or a live URL instead? Use the web version at paas.build/check.
Tools
Tool | What it does |
| Resolves a name / website / phrase into a business (uses web search) |
| Creates a real merchant account — sandbox + production — and returns scoped access tokens |
| Creates a checkout session and returns a payable link |
Configuration
Env | Default | Notes |
|
| The paas.build API (secrets stay server-side) |
The agent never holds platform keys — only scoped tokens for the vendor it created.
Why this exists
AI agents build full products in one evening — then hit the last blocker: accepting money. Traditional merchant onboarding assumes a human filling forms and waiting days. This server makes onboarding itself agent-native. Read more: Agentic payments — agents can pay, but can they get paid?
Site: paas.build · Docs for agents: paas.build/agents
React checkout:
@paasbuild/reactPowered by UniPaaS — FCA-authorised payment institution (No. 929994)
MIT © UniPaaS
mcp-name: io.github.UNIPaaS/paas-build-mcp
Available Tools
3 toolscreate_checkoutA
Create a hosted checkout session for a vendor and return a payable shortLink. The vendor must already be live (go_live). Use this to demonstrate a real payment.
| Name | Required | Description | Default |
|---|---|---|---|
| env | Yes | Environment the vendor lives in | |
| amount | Yes | Amount in major units, e.g. 50 = £50.00 | |
| currency | No | Default GBP | |
| vendorId | Yes | ||
| reference | No | Your order/invoice reference |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It states the tool creates a checkout session and returns a shortLink, and notes a prerequisite. However, it omits details like idempotency, side effects (e.g., potential charges), or rate limits.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise with two sentences, front-loading the key action and return value. Every sentence adds value without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema, the description covers the return value ('payable shortLink') and a prerequisite. For a tool with 5 parameters, it provides sufficient context for usage, though could mention the hosted nature of the checkout.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 80%, and the description adds an example for 'amount' ('e.g. 50 = £50.00') and context that 'vendor must be live', but does not elaborate on other parameters beyond what the schema provides.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's action ('create a hosted checkout session') and the return value ('payable shortLink'). It differentiates from siblings (identify_business, go_live) by specifying checkout creation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear usage context: 'Use this to demonstrate a real payment' and a prerequisite ('vendor must already be live'). It does not explicitly mention when not to use or alternatives, but the context is sufficient.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
go_liveA
Take a business live on UniPaaS — creates a payment vendor and returns access tokens so the app can start accepting payments immediately (progressive KYB, capped £1,500 individual / £2,500 company). By default provisions BOTH sandbox and production and returns a token for each. Individuals go live instantly; companies get an onboarding link to finish identity/document steps.
| Name | Required | Description | Default |
|---|---|---|---|
| env | No | Which environment(s) to provision. Default: both. | |
| No | Contact email | ||
| region | No | Where the business is registered | |
| country | No | Country name or ISO-2 code (overrides region) | |
| website | No | Website domain, if any | |
| business | Yes | Business / trading name | |
| lastName | No | ||
| firstName | No | ||
| company_no | No | Company registration number — presence makes it a company vendor; absence = individual/sole trader |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, description carries full burden. It discloses environment provisioning, KYB caps, instant vs onboarding flow. Could mention error scenarios but sufficient.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Front-loaded with key action, then details. Four sentences, no redundancy. Every sentence adds value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For 9 param tool with no output schema/annotations, covers main behaviors. Could note prerequisite (e.g., need identify_business first) but still informative.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
78% schema coverage; description adds context: default environment, caps, instant/onboarding logic. Provides business meaning beyond schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Clear verb+resource: takes a business live, creates payment vendor, returns tokens. But doesn't explicitly distinguish from siblings identify_business and create_checkout.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Describes when to use (to start accepting payments) and progressive KYB limits, but no explicit when-not or alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
identify_businessA
Identify a business from a name, website, or short phrase — using Opus 4.8 with live web search and website reading. Returns business name, what they do, website, country and region (uk/eu/us/other). Use this first to understand who the merchant is before going live.
| Name | Required | Description | Default |
|---|---|---|---|
| input | Yes | A business name, website domain, or free-text description (e.g. "clubright", "triibe.ai", "we sell candles in Austin") |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Despite no annotations, description reveals use of 'Opus 4.8 with live web search and website reading' and lists returned fields (name, what they do, website, country, region). Adds behavioral context beyond basic purpose, though misses potential limitations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences only, no fluff. First sentence states action, method, and outputs. Second sentence provides usage order. Efficient and front-loaded for quick comprehension.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple one-parameter tool with no output schema, the description covers purpose, inputs, method, outputs, and usage context. Missing details on error handling or edge cases, but complete enough for effective use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with a clear parameter description. The tool description adds examples ('clubright', 'triibe.ai', 'we sell candles in Austin') but does not surpass the baseline significantly. Adequate but not enhanced.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: identify a business from name, website, or phrase. It contrasts with siblings by advising 'Use this first... before going live', distinguishing it from go_live and create_checkout.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly says 'Use this first to understand who the merchant is before going live', providing clear when-to-use guidance relative to siblings. Lacks explicit when-not-to-use, but context suffices.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
3 tool updates
v1.0.0- First observed
create_checkout - First observed
go_live - First observed
identify_business
TDQS
Each tool has a clearly distinct purpose: identify_business identifies the merchant, go_live provisions it, and create_checkout creates a payment session. No overlap.
All tools use consistent snake_case verb_noun pattern: identify_business, go_live, create_checkout.
With only 3 tools, the surface is minimal. While it covers a basic flow, it feels thin for a payment platform; borderline acceptable.
Missing key operations like updating business info, handling refunds, or managing vendor status. The flow has dead ends after go_live and checkout, limiting agent autonomy.
Maintenance
Resources
Unclaimed servers have limited discoverability.
Looking for Admin?
If you are the server author, to access and configure the admin panel.
Related MCP Connectors
Stripe payments for AI agents. Create links, verify, manage customers.
United States payments for AI agents — Stripe checkout via Stripe. Never holds funds.
Launch products and branded checkouts on Payments AI, the Merchant of Record for AI-built apps.
1Complete financial infrastructure for AI agents — payments, lending, escrow & more.
Related MCP Servers
- AlicenseNot gradedqualityCmaintenanceBanking infrastructure for AI agents: open accounts, issue cards, send SEPA/SWIFT payments, run mass payouts, and pay invoices via natural language.2MIT
- AlicenseNot gradedqualityBmaintenanceLets AI agents accept US payments (cards, Apple Pay, Google Pay) via Stripe hosted checkout. Includes tools to create payment links and query payment status.MIT
- AlicenseNot gradedqualityBmaintenanceLets any AI agent accept payments in Ireland via Stripe's hosted checkout.MIT
- AlicenseNot gradedqualityBmaintenanceAccept crypto payments from AI agents: create an invoice in one call and get a hosted checkout link (USDC/USDT on Celo, Base, Arbitrum, Polygon, BSC). No API key, instant self-custody settlement.MIT
Latest Blog Posts
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
MCP directory API
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/UNIPaaS/paas-build-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server