标签：#payment

Agent payment protocols are converging fast. The Linux Foundation launched the x402 Foundation around a protocol initially developed by Coinbase, Cloudflare, and Stripe, with Google, AWS, Visa, Mastercard, and Circle among the organizations expressing initial support. It is increasingly framed as an "SSL for AI commerce." When a protocol reaches that stage, three things have to mature together: the specification, the interoperability suite, and the adversarial security scenarios. Today x402 has the specification and growing interoperability machinery. What is not yet visible is a normative adversarial suite every client, resource server, and facilitator must pass. There is a precedent worth sitting with. As check clearing scaled in the early Federal Reserve era, the answer was not merely a better check format. The system added a common clearing and settlement layer. The Federal Reserve could credit the collecting institution's reserve account and debit the paying institution's account, creating an independent record against which the participating banks could reconcile. The important separation was not that the Fed guaranteed every check. It was that settlement no longer depended solely on either participant's account of what happened. (Credit to Starfish on Moltbook, whose custody-split framing sharpened this for me.) This pattern exists across mature financial systems as separation of duties: the maker is not the checker. Its modern equivalent for the controls surrounding agent payments is not custody in the asset-control sense. It is an independent, reproducible assurance plane. x402 can provide independently inspectable evidence that an on-chain payment settled. That does not independently establish that every security and policy condition surrounding the payment was evaluated correctly. The payment handshake is standardizing. The assurance semantics around it are not. The party that performs a security check can attest that it ran. But its own attestation shoul

Disclosure up front: I'm Oded, co-founder of UniPaaS, the FCA-authorised Payment Institution (No. 929994) behind paas.build - so this is a vendor writing about his own product. That said, the three Base44 mechanics below are documented Base44 surfaces, and they work with any external payments API, not just ours. The wall Tell Base44 "add payments" and it installs Stripe or Base44 Payments (powered by Wix), plus Tranzila/Max for Israel. Both main options are solid if you qualify: Stripe is excellent infrastructure with first-class docs, and the Wix-powered option is native to the platform. The fine print is where builders hit a wall: Stripe live mode needs verified business and banking information before you can take a real payment. Base44 Payments requires "a business and bank account based in one of the supported countries" (their docs). The top payments request on Base44's own feedback board is "a way to setup other payment providers other than Stripe" - precisely because not every country is supported. Base44 webhooks only fire while someone is actively using your app, so 3am subscription renewals, retries and dunning silently don't run. If you have a registered company in a supported country and mostly sell one-off purchases, use the built-in Stripe path. It's the smoothest. The rest of this post is for everyone else. Base44 gives you three documented ways to wire in an external provider. I tested all three with paas.build. Here's each, and when it fits. Insertion point 1: custom MCP connection (build-time) In Base44: Settings → Account → MCP connections → Add custom MCP . Name: paas.build Server URL: https://paas.build/sse Auth: API key (your paas.build key) That's the legacy SSE endpoint Base44's form takes; streamable HTTP lives at https://paas.build/mcp for agents that support it. Base44's AI treats MCP connections as tools it can call when your request needs external data or actions. So in the editor chat you can say "use paas.build to create a live merchan

Disclosure before anything else: I'm Oded, co-founder of UniPaaS, the FCA-authorised Payment Institution (No. 929994) behind paas.build, and we compete with Paddle. The title above is the sentence builders keep arriving with - right here on dev.to , in Hacker News threads , and in our inbox. This is the map I give them, including the branches where Paddle is still the right call. Why good products get rejected Paddle is a Merchant of Record. The moment it approves you, it becomes the legal seller of everything you sell. So its underwriting answers exactly one question: "do we want to legally own this business's sales?" A brand-new solo builder with no history is the riskiest possible answer to that question, regardless of how good the product is. Builders who have been through it report the same four themes: No prior processing history. The chicken-and-egg: you need a payments track record to get approved, and you need approval to build a track record. An incomplete-looking site. Missing terms, no pricing page, no live domain, no visible product. Reviewers open your site. Identity mismatches. The applying entity, the domain owner and the bank account don't line up. Category restrictions. Paddle has tightened around some generative-AI products. Very little of this is documented, which is why the rejection email feels random. It isn't. It's a business model doing exactly what it was built to do. The decision tree Two questions decide your next move. 1. Is "global tax handled for me" your top requirement? If yes, stay in the MoR category. This is Paddle's genuine strength, and it's a real one: as Merchant of Record it remits VAT/GST across 100+ jurisdictions, and that liability sits with them, not you. No PayFac gives you that. Don't switch categories - fix the application and get back in the queue: Make the site look finished. Live domain, real pricing page, terms of service, privacy policy, a working demo. Explain the business plainly. What you sell, to whom, expecte

The Problem: Why Most Telegram Payment Bots Fail You've built a Telegram bot that sells digital courses, takes coffee orders, or offers freelance services. Traffic is flowing. But when your bot tries to collect payment, you hit a wall: Payment gateways demand hefty setup fees and compliance audits You end up holding customer money in an intermediary account (legal liability) Settlement takes 3–5 days, frustrating both you and buyers Integration is a maze of webhooks, IPNs, and error handling A founder we know spent two weeks wrestling with Stripe's Telegram integration, only to discover the monthly fee ate 40% of his margins on $2–5 transactions. He needed something lighter, faster, and truly peer-to-peer. Enter AgentPay VN : an open-source Python SDK that lets your Telegram bot generate QR codes pointing directly to your bank account. No middleman. No holding funds. Just instant VietQR payments via the banking system Vietnameses already use daily. What Is AgentPay VN? AgentPay VN is an MIT-licensed Python SDK + MCP server that orchestrates VietQR payment requests. Here's the mental model: You create a payment request in your bot (e.g., "Customer ordered coffee for 50,000 VND") AgentPay generates a checkout URL with an embedded QR code Customer scans → pays → bank confirms settlement in seconds Your bot receives a webhook callback and fulfills the order The key: AgentPay never touches money . The QR points straight at your merchant bank account. A bank feed confirms settlement. You own the transaction end-to-end. Why Telegram + VietQR? Telegram has 180+ million users , with especially strong adoption in Southeast Asia. Vietnamese merchants already use banking apps (MB Bank, Techcombank, VCB) that natively support VietQR scanning. Your bot becomes a natural extension of their daily workflow: Customer receives a payment link in chat Opens the QR code (in-app or screenshot) Scans with their banking app (2–3 taps) Money clears to your account in minutes Bot auto-confirm

Everyone is building rails for AI agents to spend money. Google's AP2 gives agents payment mandates. Coinbase's x402 pattern turns HTTP 402 into machine-to-machine micropayments. Agent wallets are everywhere. But watch what agents actually do all day in 2026: they build products. A Lovable app in an evening. A SaaS in Cursor over a weekend. And every one of those products eventually needs the thing no spending protocol covers — accepting money. The wall every agent hits Here's a session I've watched a hundred times: ➜ ~ claude "finish my app" ✓ scaffold — Next.js + Tailwind ✓ UI — components & design system ✓ UX — onboarding flow polished ✓ auth — Google sign-in wired ✓ database — schema + migrations ✓ deploy — production live ▸ application is almost ready… ✗ missing: payments And then the agent — which just shipped a full product in one session — tells you: "To accept payments you need a merchant account. Traditional PSP onboarding requires a compliance review — expect to wait at least a week for approval." An app built in an evening, waiting 7 days for permission to charge £1. That's not risk management. That's a workflow designed when software took months to ship, and nobody went back to fix it. Your other options aren't better: no company? The classic path detours through Stripe Atlas ($500) and an IRS EIN wait that stretches to weeks for non-US founders — before you can even apply . Software's bottleneck has moved — from writing code to accepting payments. What "agent-native" means on the merchant side The spending side got protocols. The earning side needs four properties: 1. Machine-readable everything. Docs an agent consumes in one pass — llms.txt , agents-first API references. The integrating developer is increasingly not a human. 2. Provisioning tools, not just management tools. Stripe's MCP server can operate an account you already have — customers, refunds, invoices. The agent-native question is one level deeper: create the account. 3. Progressive KYB. G

Two weeks ago Visa invested in Replit. Not for code collaboration. For agentic payments. TechCrunch reported it on May 28: Visa put money into Replit specifically to "power agentic payments for developers." Over 1,000 Visa employees already use Replit for prototyping. Now they're building the pipes for autonomous agents to spend money. Here's why this matters: Visa doesn't make bets on developer tools. They make bets on payment volume. When they invest in agentic payment infrastructure, they're not guessing — they see the transaction data. And the data says autonomous agents are about to move real money. The question for developers: when your agent needs to pay for an API, a cloud instance, or another agent's service, what tooling stack do you actually use? The Stack Nobody Agrees On Right now there's no standard agent payment stack. But a pattern is emerging across the open-source projects shipping on HN: Layer 1: The Authorization Wrapper Before your agent touches money, something needs to say yes or no. Three approaches are competing: Budget Caps — Set a dollar limit per agent, per day, per category. Tools like AgentBudget and RunCycles enforce limits before execution. Simple, but brittle — what happens when your agent hits the cap mid-task? Policy Layers — Define rules: "Agent A can spend up to $50/day on OpenAI, $200/month on AWS, nothing on ad platforms." Tools like Ledge and PaySentry ship policy engines that evaluate every transaction against a rule set. More flexible than caps, but policy management becomes its own problem at scale. Spending Mandates — The agent gets a formal spending authorization with scope, duration, and approver. Nornr takes this approach: before the agent can spend, a human signs off on a mandate document. Most audit-friendly, least autonomous. Layer 2: The Payment Rail Once authorized, the agent needs to actually move money. The options: Rail Best For Limitation Stripe Agent SDK Subscription SaaS, metered APIs Requires merchant accoun

If you've ever worked on an e-commerce project in Chile, sooner or later you bump into Transbank. There's no avoiding it. I built a reference template that use NestJS on the backend and Next.js 16 on the frontend, and in this post I want to walk you through the whole thing: what Webpay Plus actually is, why the integration looks the way it does, and how each piece fits together. Github Repository Reference: Link A bit of context Webpay Plus is one of the most important online payment methods in Chile. The user experience is straightforward: your customer enters an amount on your site, gets redirected to Transbank's branded payment page, fills in their card details there, and comes back to your site with a result. From a UX perspective it's not as slick as Stripe Elements or a fully embedded checkout — the user always sees Transbank's domain in the address bar during the payment — but from a developer's perspective that's actually a feature. You never touch card numbers. PCI scope stays minimal. Transbank handles 3D Secure, fraud rules, and bank routing. The trade-off is that the integration model is what you might politely call classical . It's built around full-page redirects and form POSTs, not modern APIs with JSON responses and webhooks. That's important to understand up front, because it shapes every decision you'll make in the code. The integration flow, step by step Before looking at any code, it helps to have a clear mental model of what's happening . There are three distinct moments where your system talks to Transbank's system, and each one has a specific shape. First Step: When the customer clicks "Pay", the backend asks Transbank to create a transaction (amount, order ID, return URL) . Transbank returns a transaction token and a redirect URL where you must send the user. Second Step: Transbank requires the redirect to be an HTTP POST with the token in a token_ws form field, so you must generate an HTML form with a hidden token_ws input and submit it prog

Uber introduced a high-throughput financial ledger processing system designed to handle hot account write contention at scale. Using 250ms batching, Redis coordination, and optimistic atomic updates, the system supports 30+ updates per second per account while preserving consistency and auditability, reducing multi-hour processing pipelines to minutes in its distributed accounting infrastructure. By Leela Kumili

A SaaS team adds “Pay with crypto” to checkout. The first test looks fine: create a wallet address, show a QR code, receive USDT, mark the order as paid. Then production starts. One customer sends the right amount on the wrong network. Another pays after the invoice expires. A third sends 99.80 USDT instead of 100 USDT. Support sees a transaction hash but cannot find the order. Finance sees funds received but cannot match them to an invoice. The backend receives the same webhook twice and unlocks the product twice. That is the moment crypto payment integration stops being a QR-code feature and becomes a payment infrastructure problem. This is the first Dev.to post from Cryptoway . We build crypto payment infrastructure for online businesses, and here we will share practical notes about crypto payment API design, invoices, payment webhooks, stablecoin payments, checkout flows, reconciliation and payment status handling. What is a crypto payment gateway? A crypto payment gateway is the layer between a business event and a blockchain transaction. The business event can be: a SaaS subscription invoice; an e-commerce order; a digital product purchase; a marketplace deposit; a service payment link; an internal billing event. The blockchain transaction is the customer sending BTC, ETH, USDT, USDC or another supported digital asset. The gateway connects the two. It creates a payment request, shows the customer what to pay, monitors the blockchain, updates the payment status and notifies your backend when something changes. In other words: a crypto payment gateway is not the blockchain itself. It is the operational layer that makes blockchain-based payments usable inside real products. Crypto Payment Gateway vs Wallet Address A wallet address is enough for a manual payment. It is not enough for a product that needs order tracking, support visibility and finance reconciliation. Area Wallet address only Crypto payment gateway Order matching Manual matching by amount, address o

The British fintech has built a waitlist of about 450,000 users in India as it prepares for a broader launch.

Visa said that over 1,000 employees has been using Replit for prototyping and development