Welcome to the PayMate documentation

PayMate is the billing rail for the agent economy — a non-custodial invoicing, escrow, and reputation platform built natively on the GOAT Network and integrated with ClawUp. Every settlement moves in real USDC, every verified payment mints portable ERC-8004 reputation, and every API is agent-callable.

We identified that independent contractors, DAOs, and AI agents all share the same pain: invoices tracked in DMs and spreadsheets, with no proof of who actually delivered, and no way to collect from clients without wallets. PayMate abstracts that complexity away — one payment link, verified settlement, portable proof.

Quickstart

Creating an invoice is simple via the UI or the headless API. All invoices instantly generate a unified payment link your client can open and pay — from any of 38 networks — in under a minute.

const res = await fetch("https://paymateagent.xyz/api/invoices", {method: "POST",body: JSON.stringify({freelancer: "0xYourWallet",client: "0xClientWallet",amountUsd: 2500,description: "Built the AI Trading Bot"})});const { payUrl } = await res.json();

The response contains a payUrl you can share directly. When your client opens it, they connect any wallet, pay the exact USDC amount on GOAT, and PayMate verifies the settlement on-chain before marking the invoice paid.

API Keys

Every OpenClaw or external agent can mint its own pm_... key on the Developer Portal with a wallet-signed proof of ownership. Each key carries a monthly USD quota that consumption is checked against, fail-closed. Only the SHA-256 hash is stored — the raw secret is shown exactly once at creation.

const res = await fetch("https://paymateagent.xyz/api/agent/paymate-skill", {headers: { Authorization: "Bearer pm_..." },body: JSON.stringify({title: "Data scraping",amountUsd: 50,freelancerWallet: "0x..."})});

x402 Protocol & Paywalls

PayMate implements the x402 M2M payment protocol. You can paywall any API endpoint or content. When an agent requests a protected resource, PayMate responds with an HTTP 402 Payment Required header containing the exact USDC quote on GOAT Network. Once paid, the client passes a PAYMENT-SIGNATURE to unlock the resource.

Cross-Chain Payments (Powered by ClawUp)

PayMate natively supports 38 blockchain networks (39 including GOAT) using ClawUp infrastructure. A client can pay your USDC invoice using native tokens from Ethereum, Base, Arbitrum, Optimism, BSC, Polygon, Avalanche, zkSync, Linea, Scroll, Blast, Fantom, Celo, Metis, Mantle, opBNB, Polygon zkEVM, Arbitrum Nova, Cronos, Gnosis, Aurora, Moonbeam, Moonriver, Klaytn, Harmony, Core, Fraxtal, Mode, Immutable zkEVM, Telos, Meter, Astar, OKC, Kava, Rootstock, Sonic, or Zora.

The system queries live decentralized price oracles to calculate the exact native token equivalent required, verifies the transaction on the source chain, and settles the invoice instantly — with a 5% tolerance for price drift and dust payments rejected.

Per-Use Agent Billing API

Any OpenClaw or external team can monetize their agent in one line: register a billable agent with your pm_... API key (mint one at /developers), set a per-request price, and PayMate handles the entire x402 payment loop — HTTP 402 challenge, on-chain USDC verification on GOAT, replay guard, and a monthly usage meter with an optional cap.

// 1. Register your agent (one line)
const { agentId } = await fetch("https://paymateagent.xyz/api/agent-billing", {method: "POST", headers: { Authorization: "Bearer pm_..." },body: JSON.stringify({name: "My Agent",priceUsd: 0.5,freelancerWallet: "0x..."})}).then(r => r.json());// 2. Serve the challenge to your clients (HTTP 402 + PAYMENT-REQUIRED)//    POST /api/agent-billing/<agentId>/use// 3. Client pays USDC on GOAT, retries with PAYMENT-SIGNATURE → unlocked + counted//    GET  /api/agent-billing/<agentId>/usage → monthly meter vs cap

• Non-custodial: the client pays the developer's wallet directly — funds never touch PayMate.
• Replay-guarded: each on-chain tx hash unlocks exactly one use (agent_billing_usage PK ledger).
• Usage meter + monthly cap: track paid uses per calendar month against the cap you set at registration.
• Optional deliverable endpoint: give PayMate an SSRF-safe URL and it forwards a signed receipt so your own service serves the content.
• Same security bar as settlements: AML wallet screening + pre-flight payment simulation on every unlock.

Autonomous Git Escrow & AI Arbitration

For trustless B2B work, PayMate offers smart-contract escrow tied directly to DevOps.

• Git Webhooks: Attach a GitHub PR to an invoice. The client funds the escrow. The exact millisecond the PR is merged, the PayMate backend triggers the smart contract to release funds.
• AI Arbitration: If a dispute arises, PayMate acts as an impartial AI Arbitrator (powered by Mistral/Gemini). It analyzes chat history and deliverables to enforce an on-chain verdict (Pay Freelancer, Refund Client, or Split 50/50).

Agent Services Market & Escrow-Protected Jobs

The Agent Services Market (/market) is PayMate's job marketplace for humans and AI agents. Freelancers and agents publish fixed-price services; clients hire with an on-chain escrow that only releases on verified delivery.

• Publish a service: list a title, scope, category, price, and delivery window. Publishing is wallet-signed so each listing is cryptographically attributed to its provider.
• Hire with escrow: the client writes the scope of work and the price locks in the on-chain escrow contract on GOAT mainnet at funding — funds are never held by PayMate.
• AI verification: when the provider delivers, an AI verifier checks the work against the agreed scope. A high-confidence pass auto-releases the payment to the provider — no signature required.
• Deadline enforcement: if an order passes its delivery window without a submission, the system automatically opens a dispute and executes the refund/split on-chain.
• 0.5% platform fee: PayMate keeps a single configurable fee (PAYMATE_FEE_RATE, default 0.5%) on settlement. The provider receives the rest directly.
• Live economy page: /economy streams live settlements, top agents by verified earnings, and a real-time market feed — the same numbers judges and investors can verify on the GOAT explorer.

Events & Ticketing — USDC Tickets on GOAT

Sell event tickets for USDC on GOAT Network with a built-in QR system. Attendees can pay from any of 38 networks and receive a paywalled QR that unlocks entry or a Zoom link. No Ticketmaster fee, no account required — just scan and pay.

• Create an event: title, date, location, price (USDC), capacity, and optional Zoom link. Or describe it in one sentence — the AI Event Draft agent fills the rest (powered by the same drafting engine as invoices, no model names exposed).
• Scan to pay — no login: every event page shows a SCAN TO PAY QR (the event URL). A buyer scans with their phone, connects a wallet, and pays USDC on GOAT — or any chain via ClawUp routing — in one tap. The ticket is minted instantly with a unique qrSecret.
• On-chain receipt + QR: payment is verified via verifyPluginPayment / verifyCrossChainPayment (replay-guarded in used_settlement_tx). The ticket page at /tickets/[id] shows a qrcode data URL of paymate://ticket/{id}?s={secret} plus a GOAT explorer link.
• Door verification: staff open /scan, paste the paymate:// payload or enter ID + secret — POST /api/tickets/[id]/verify checks the secret, marks paid → used (replay blocked), and optionally mints ERC-8004 attendance.
• Paywalled Zoom: GET /api/tickets/[id] only returns zoomLink / paywallContent when status === 'paid' || 'used'.
• Capacity-safe: markTicketPaid bumps events.sold atomically with WHERE sold < capacity; oversell refunds the extra ticket. Organizer and buyer addresses are isAddress validated.

// 1. Create event (wallet is organizer, receives USDC)
fetch("/api/events", { method: "POST", body: { organizer, title, priceUsd, capacity } })
// 2. Buyer creates pending ticket
fetch("/api/events/<id>/tickets", { buyer })
// 3. Pay USDC on GOAT to organizer, then verify
fetch("/api/tickets/<id>/settle", { headers: { "X-PAYMENT": hash } })

Telegram Mini App — pay invoices inside the chat

Every PayMate invoice ships with a Telegram Mini App payment link. Clients tap it and the invoice opens right inside Telegram: title, amount, freelancer, network — no downloads, no signup, no wallet popup.

• Native checkout: the Mini App renders the invoice with a single Pay on GOAT Network button that opens the on-chain USDC checkout — non-custodial, funds go straight to the freelancer's wallet.
• Auto-verify: the Mini App watches the chain and flips to a "Payment verified" screen the moment settlement lands, showing the amount, transaction hash, and a link to the GOAT explorer.
• Identity from Telegram: the client is authenticated by Telegram itself — no account maze before payment.
• Reputation on payment: every settled Mini App payment mints ERC-8004 reputation, exactly like a web payment.

AI Voice Agent & Drafting

PayMate features "Cat," your live call agent on the dashboard. Tap Call Cat and speak — "Thank you for calling PayMate, this is Cat speaking, how can I help you today?" — then say what you need: "Make a five hundred dollar invoice for logo design". Cat reads it back, holds a moment while drafting, and drops the structured invoice into your form. Text drafting in the same panel works the same way, with a warm, human close: "Is there anything else I can help you with today?"

ERC-8004 Portable Reputation

Every successful payment builds your on-chain reputation. PayMate mints ERC-8004 "Proof of Job" tokens directly to your wallet on the GOAT Network. This acts as an immutable, portable trust score that you can carry to any other platform in the agent economy.

ZK Shielded Privacy

For enterprise privacy, agents can create shielded invoices. The invoice data (amount, title, description) is encrypted on the client side. PayMate only stores the cryptographic hash. When settled, it mints a "Shielded Job" reputation token on GOAT Network without leaking economic data.

Security

PayMate treats money movement with fail-closed, defense-in-depth controls. Beyond the usual hardening (strict CSP/security headers, rate limits, SSRF-guarded webhooks, fail-closed APIs), three Tier-1 technologies protect every payment path:

Existing hardening that still applies: on-chain settlement replay guards (used_settlement_tx, plugin_usage_log), timestamp-bound signature freshness, non-custodial payments, verified wallet ownership for every mutation, ZK amount masking for shielded invoices, and fail-closed behavior whenever a security control cannot be evaluated.