DEV Community: Umang Gupta

x402 Protocol for Indian Developers: Monetize APIs in USDC (2026)

Umang Gupta — Thu, 23 Apr 2026 07:20:20 +0000

Published April 16, 2026
·
By MoltPe Team

x402 is an HTTP protocol for pay-per-call APIs in USDC. Indian developers can use it to charge global users per API call, receiving USDC directly to their MoltPe wallet — no subscriptions, no invoicing, no forex. The server returns HTTP 402 with a price; the client signs a payment; the server delivers the response.

Why Indian API Builders Should Care

If you are building an API business from India and serving global users, the payment stack is the ugliest part of the job. Stripe India is gated behind business verification that not every indie founder clears. Razorpay international is improving but still friction-heavy for true pay-per-call pricing. Subscriptions add dunning, failed-card handling, and monthly refund cycles. Invoicing B2B customers outside India means 30 to 60 day payment terms, GST export documentation, and forex conversion losses.

Meanwhile, the actual product you are selling is a single HTTP call. A sentiment analysis API. A translation endpoint. A real-time cricket data feed. A code-generation model. A compliance-check microservice. Each call takes milliseconds and is worth a fraction of a cent to a few cents. Trying to wrap that inside a monthly subscription forces you to pick prices that are either too high for tiny users or too low for heavy users. Most Indian API builders end up leaving money on the table.

x402 solves this by pricing at the HTTP layer. Your server returns a 402 Payment Required status with the exact cost of the specific call. The client signs a USDC payment, retries the request, and the server delivers the resource. No subscription, no contract, no invoice. The USDC lands in your MoltPe wallet seconds after the call completes.

For Indian builders specifically:

No Stripe gate. You do not need Stripe India approval, a registered company, or a merchant account. A wallet address is enough.
No forex leakage. You receive USDC. Convert to INR on your schedule, at the rate you choose.
Global by default. A developer in Berlin, an agent in San Francisco, and a SaaS in Singapore all pay you the same way.
Usage-based pricing that actually works. You can charge $0.0005 per inference and still be profitable because settlement overhead is gasless on MoltPe-supported networks.

How x402 Works — The Protocol

x402 reuses the HTTP 402 Payment Required status code that has been reserved in the HTTP spec since 1999. Four steps cover the core flow:

Client hits endpoint. A normal HTTP request, nothing special — GET /v1/summarize?text=...
Server returns 402. Response is HTTP 402 Payment Required with headers describing price, token (USDC), network (Polygon PoS or Base), and recipient wallet.
Client signs payment intent. Using an agent wallet, the client constructs a signed payment. With MoltPe, this happens automatically inside the client SDK.
Client retries with X-PAYMENT header. Same request, now with payment proof. The server verifies on-chain, then returns 200 OK with the actual data.

The elegance: the entire flow uses vanilla HTTP. You do not need a new transport, a new auth scheme, or a payment-specific middleware. Any Express, FastAPI, Hono, or Fiber server can add x402 support with a few lines of code.

Code: Expose a Paid API Endpoint

A sentiment analysis endpoint priced at $0.01 USDC per call. Node.js + Express, with MoltPe handling wallet management and on-chain verification.

// server.js — Indian sentiment API priced at $0.01 USDC per call
import express from "express";
import { MoltPe } from "@moltpe/server-sdk";

const app = express();
app.use(express.json());

const moltpe = new MoltPe({
  apiKey: process.env.MOLTPE_API_KEY,
  recipientWallet: process.env.RECIPIENT_WALLET,
  network: "polygon",
});

const PRICE_USDC_UNITS = 10000; // USDC has 6 decimals; 10000 = $0.01

app.post("/v1/sentiment", async (req, res) => {
  const proof = req.header("X-PAYMENT");

  if (!proof) {
    return res.status(402).set({
      "X-Payment-Amount": PRICE_USDC_UNITS,
      "X-Payment-Token": "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359",
      "X-Payment-Network": "polygon",
      "X-Payment-Recipient": process.env.RECIPIENT_WALLET,
      "X-Payment-Expiry": Math.floor(Date.now() / 1000) + 300,
    }).json({ error: "payment_required", price_usd: "0.01" });
  }

  const verified = await moltpe.verifyPayment({
    proof,
    expectedAmount: PRICE_USDC_UNITS,
    expectedRecipient: process.env.RECIPIENT_WALLET,
    network: "polygon",
  });

  if (!verified.ok) {
    return res.status(402).json({ error: "invalid_payment", reason: verified.reason });
  }

  const { text } = req.body;
  const score = await analyzeSentiment(text);

  return res.status(200).json({ sentiment: score, paid: true, tx: verified.txHash });
});

app.listen(3000, () => console.log("x402 sentiment API on :3000"));

No Stripe webhook handler, no customer table, no invoice generator. The USDC lands in your MoltPe wallet within seconds.

Client-side (handling 402 and retrying with payment):

// client.js — calls the sentiment API, handles 402, signs, retries
import { MoltPeClient } from "@moltpe/client-sdk";

const wallet = new MoltPeClient({
  agentKey: process.env.AGENT_KEY,
  maxPerCallUsd: 0.05,
});

async function getSentiment(text) {
  const url = "https://api.yourcompany.in/v1/sentiment";
  const body = JSON.stringify({ text });

  let res = await fetch(url, { method: "POST", headers: { "Content-Type": "application/json" }, body });

  if (res.status === 402) {
    const proof = await wallet.signX402Payment({
      amount: res.headers.get("X-Payment-Amount"),
      token: res.headers.get("X-Payment-Token"),
      network: res.headers.get("X-Payment-Network"),
      recipient: res.headers.get("X-Payment-Recipient"),
    });

    res = await fetch(url, {
      method: "POST",
      headers: { "Content-Type": "application/json", "X-PAYMENT": proof },
      body,
    });
  }

  return res.json();
}

console.log(await getSentiment("The new Bangalore metro is fantastic"));

Two HTTP calls. One signed payment. One USDC deposit to your wallet. That is the whole loop.

Code: Consume a Paid API From an Agent

An autonomous consumer pattern with spending policies and caching:

// agent.js — Indian-built research agent calling paid external APIs
import { MoltPeAgent } from "@moltpe/agent-sdk";
import { LRUCache } from "lru-cache";

const agent = new MoltPeAgent({
  agentId: "research-bot-v1",
  wallet: process.env.AGENT_WALLET,
  policies: {
    maxPerCallUsd: 0.02,
    maxPerDayUsd: 5.0,
    allowedNetworks: ["polygon", "base"],
  },
});

const cache = new LRUCache({ max: 500, ttl: 1000 * 60 * 60 });

async function fetchPaidData(endpoint, params) {
  const key = endpoint + JSON.stringify(params);
  if (cache.has(key)) return cache.get(key);

  const response = await agent.callX402({ url: endpoint, method: "GET", query: params });

  if (response.status !== 200) throw new Error(`paid call failed: ${response.status}`);

  cache.set(key, response.data);
  return response.data;
}

const fundamentals = await fetchPaidData(
  "https://api.finprovider.com/v1/fundamentals",
  { ticker: "TCS", exchange: "NSE" }
);
console.log("Revenue growth:", fundamentals.revenueGrowth);

The policies block does real work: if an upstream server demands $0.50 per call, the agent refuses before any payment is signed. The daily cap protects against infinite loops. The cache means you never pay twice for the same query in an hour.

Indian Use Cases

Indian AI SaaS charging per inference. You have fine-tuned a model in Hyderabad that does Hindi-to-English legal translation. Instead of $29/month tiers, charge $0.001 per paragraph. Global law firms, Indian legal-tech startups, and research agents all pay the same way.

Indian data providers selling to global AI agents. A real-time feed of Indian equity market data, weather for agritech, or cricket statistics. With x402, any autonomous agent in the world can discover your endpoint and pay $0.005 per data point, no sales cycle, no contract.

Indian dev tools with pay-per-use pricing. A code search index, a security scanner, or a dependency-graph API — priced per call instead of forcing small teams into enterprise plans.

Freelance Indian devs monetizing micro-APIs. A GSTIN validator, a Pincode-to-coordinates lookup, a shipping-cost estimator. Deploy once, price at $0.0005, point the endpoint through MoltPe, and leave it running. No company registration required to accept payment.

All four patterns share the same shape: a small, fast HTTP service, priced per call, paid in USDC, settled automatically.

Frequently Asked Questions

What programming languages work with x402?

Any language that can make HTTP requests — Node.js, Python, Go, Java, Rust, PHP, Ruby, and shell scripts with cURL can both serve and consume x402 endpoints. MoltPe provides a reference Node.js implementation and a REST proxy that works from any language.

Do my Indian API users need to know crypto?

No. Your users interact with your API normally. The x402 payment flow happens inside their client SDK or agent runtime. If your users are AI agents on MoltPe, the agent handles payment automatically.

How much per-call revenue can realistically flow through x402?

Typical pricing from Indian API builders: $0.0005 per inference (lightweight AI models), $0.001 to $0.01 per data query, $0.10 to $5 for heavy compute jobs. Because settlement is gasless via MoltPe on Polygon PoS or Base, even $0.0005 calls are economically viable.

Is x402 production-ready?

Yes. x402 has processed over 50 million transactions across implementations and is supported natively by MoltPe, Coinbase Agent Kit, and multiple SDKs. The protocol itself is simple (two HTTP requests), and the underlying settlement rails (USDC on Polygon PoS and Base) have been production-grade for years.

How does x402 compare to subscription billing for Indian SaaS?

Subscription billing requires approval, monthly invoicing, dunning flows, and forex reconciliation when serving global customers. x402 eliminates all of this: customers pay per call in USDC, you receive USDC directly to your wallet, and there is no monthly cycle to manage. Subscriptions still make sense for high-volume human-facing products. x402 wins for API-first products and any scenario where the customer is another piece of software.

Originally published at https://moltpe.com/blog/x402-protocol-india-developers. MoltPe is AI-native payment infrastructure that gives AI agents isolated wallets with programmable spending policies for autonomous USDC transactions. Get started free

The Complete Payments Infrastructure Stack for Indian AI Startups in 2026

Umang Gupta — Thu, 23 Apr 2026 07:19:01 +0000

Published April 16, 2026
·
By MoltPe Team

Indian AI startups in 2026 need a three-layer payments stack: Layer 1 domestic fiat (Razorpay, Cashfree, or UPI) for INR from Indian customers, Layer 2 international USDC via MoltPe for global B2B and B2C, and Layer 3 agent-to-agent rails (x402 and MPP) for AI-native revenue. No single provider covers all three, which is why architecture matters more than vendor choice.

Why Payment Infrastructure Matters More for AI Startups

Most Indian SaaS startups have one type of customer: humans paying for software in one currency. A single payment gateway covers the entire revenue motion. AI startups do not get to be that simple.

An Indian AI startup in 2026 typically has three distinct counterparty types:

Indian customers — a Bengaluru marketing team buying your AI writing tool, paying in INR via UPI, cards, or netbanking
Global customers — a US or London agency buying the same product, paying in USD via cards, ACH, or USDC
AI agents — another company's autonomous agent calling your API, or your own agent calling a third-party data API

A single payment provider does not cover all three. Razorpay is excellent for Indian fiat but was never designed for USDC settlement or agent micropayments. Stripe has broad card coverage but carries real restrictions for AI businesses in India. Crypto-native rails solve the international and agent problem but do not help you accept UPI from a Pune SMB.

The answer is a stack, with each layer chosen for the job it does best, and a clean routing decision in your backend that picks the right layer per transaction.

Layer 1: Domestic Fiat (Razorpay / Cashfree / UPI)

For INR revenue from Indian customers, you want an Indian domestic gateway. Three mainstream options for AI SaaS:

Razorpay is the default choice. It supports UPI, cards, netbanking, wallets, and recurring mandates out of the box, with mature subscription tooling and strong SDK coverage. Gets you to a working checkout in a day.

Cashfree is a credible alternative with competitive pricing, strong payout support, and solid UPI coverage. Teams that need both collection and payouts in one vendor often prefer Cashfree.

Direct UPI integration via a PSP is worth considering only at very high volume where gateway margin becomes material. For most startups under $5M ARR, the engineering cost outweighs the savings.

One architectural note: treat the domestic gateway as a module your backend talks to via an interface, not as a wrapper scattered across your codebase. When Layers 2 and 3 arrive, you want to swap implementations, not rewrite your billing logic.

Layer 2: International (MoltPe + USDC)

The second layer handles money coming from outside India. This is where most Indian AI startups hit unexpected friction.

The obvious choice is Stripe, and for pure card-based B2C, Stripe is fine. But Stripe India imposes restrictions on AI, crypto, and unusual business models that catch AI startups by surprise. Accounts get placed in review when the description mentions autonomous agents, on-chain integrations, or financial automation. New accounts face 30-day hold periods. Forex conversion from USD to INR is opaque with spreads that compress gross margin on low-priced SaaS plans.

USDC on MoltPe is a different model entirely. Settlement is instant — typically sub-second on Polygon PoS, Base, or Tempo. There is no forex layer because USDC is already dollar-denominated; conversion to INR happens on your schedule. Gas fees are zero on the supported chains. And USDC is programmable, which matters for Layer 3.

For B2B customers, this gets even cleaner. US agencies, crypto-native funds, and web3 companies increasingly prefer paying in stablecoins because it avoids their own international wire costs. Offering a USDC option can close deals faster, not slower.

A minimal receive flow:

// Create an invoice payable in USDC
const invoice = await moltpe.invoices.create({
  amount_usdc: 499.00,
  memo: `inv-${customer.id}-2026-04`,
  chain: 'base',
  webhook_url: 'https://api.yourstartup.in/moltpe/webhook'
});

// Send invoice.hosted_url to the customer.
// Webhook marks the invoice as paid when MoltPe confirms on-chain settlement.

The same MoltPe account that handles inbound USDC from customers also underpins Layer 3, so you are not standing up two separate systems.

Layer 3: Agent-to-Agent (MoltPe + x402/MPP)

This is the tier that did not exist 18 months ago and still does not exist at most Indian AI startups. It will over the next 24 months.

Agent-to-agent payments are transactions where software pays software without a human in the loop. Your AI coding assistant needs to call a third-party code-search API that charges per call. Traditionally, you would sign up for an API key, pre-pay for a monthly plan, and hope your usage matches the tier. With the x402 protocol, your agent pays per call at the moment of use: the API returns HTTP 402 with a price, your agent's MoltPe wallet signs a USDC payment, the call completes. You only pay for what you used.

The mirror case is equally important. If your AI startup exposes an API, other agents will want to consume it. Supporting x402 on your API is how you capture agent revenue. This is a distribution question, not a crypto question.

A concrete example: you run an AI legal research product for Indian corporate teams. Your agent needs to pull recent case law from a third-party legal database, which charges per query. You give your agent a MoltPe wallet funded with USDC, with a programmable spending policy capped at roughly the rupee equivalent of ₹500 per day. The agent calls the legal database via x402. Each call costs a few cents. If the agent misbehaves, the wallet enforces the cap at the infrastructure level — losses are bounded regardless of what the model does.

The second protocol to know is MPP (Machine Payments Protocol). Where x402 is great for pay-per-call micropayments, MPP handles agent-to-agent negotiation and routing. MoltPe supports both from a single wallet.

Setting up agent receiving is almost free. Waiting until a real agent-sourced deal is on the table and then realising your infrastructure cannot accept the payment is expensive.

Integration Architecture

The three layers compose through a routing layer in your backend:

                   Indian customer (INR)
                           |
                           v
                 +---------------------+
                 |  Razorpay / Cashfree|
                 +---------------------+
                           |
Global customer (USDC) -> [ Payment Router in your backend ]
                           |
                 +---------------------+
                 |      MoltPe         |
                 |  (inbound USDC +    |
                 |   outbound x402/MPP)|
                 +---------------------+
                           ^
                           |
     Your agent calling a third-party AI API (x402)

The router is deliberately thin. It decides which rail a transaction uses based on customer region, currency, and whether the counterparty is a human or an agent. It does not contain business logic. Your invoicing, metering, and product code stay above the router.

Common Mistakes Indian AI Startups Make

Forcing Stripe India to handle everything. Stripe India is good at neither UPI (Razorpay is better and cheaper) nor USDC (it does not do it natively) nor per-call agent micropayments. The result is a gateway that technically works but leaves money on the table in every layer.

Ignoring the agent-to-agent layer until a competitor launches it. The typical pattern: a competitor announces x402 support, an enterprise customer asks about it in a sales call, and suddenly the engineering team has a fire drill to stand up Layer 3 in two weeks. Setting it up when you have time is much cheaper.

Not setting up USDC receiving before the first global customer. The week your first US customer signs the contract is a bad week to discover that your Stripe account is in review. Stand up Layer 2 before you need it. The cost of an unused USDC wallet is zero.

Giving agents access to funds without spending policies. An agent without a spend cap is a vulnerability. A prompt injection, a bug in a tool call, or a hallucinated loop can drain a wallet in minutes. MoltPe enforces spending policies at the wallet level: daily limits, per-transaction caps, recipient allowlists. Treat them the way you treat database backups.

Mixing layers in the product code. The routing decision belongs in one place. If Razorpay logic, USDC logic, and x402 logic are scattered across your codebase, any change becomes a three-system migration.

Frequently Asked Questions

What is the minimum startup size where this three-layer stack makes sense?

If you have paying customers in both India and outside India, or plan to expose an API that AI systems consume, the three-layer stack is already worth setting up. The domestic layer takes a weekend to integrate. The international USDC layer via MoltPe takes under an hour for a basic receive flow. The agent-to-agent layer can be switched on later without refactoring the other two.

Do we need to be registered outside India to accept USDC payments?

No. MoltPe works for Indian entities receiving USDC from global customers. You still need to report foreign revenue correctly under Indian tax and FEMA rules — consult a CA for the accounting treatment.

Can we use MoltPe alongside our existing Razorpay setup?

Yes. MoltPe and Razorpay solve different problems and are designed to coexist. Razorpay handles INR from Indian customers via UPI, cards, and netbanking. MoltPe handles USDC from global customers and agent-to-agent transactions. Most Indian AI startups that go multi-region run this exact split.

How does MoltPe compare to Stripe for Indian AI startups?

Stripe India has meaningful restrictions on AI, crypto, and unusual business models, along with 30-day hold periods and opaque forex conversion. MoltPe settles in USDC instantly on Polygon PoS, Base, and Tempo, with zero gas fees and no forex layer. For agent-to-agent revenue, Stripe has no native equivalent to x402 or MPP today.

Originally published at https://moltpe.com/blog/ai-startup-india-payments-infrastructure. MoltPe is AI-native payment infrastructure that gives AI agents isolated wallets with programmable spending policies for autonomous USDC transactions. Get started free

How Freelance AI Developers in India Get Paid in 2026 Without Losing 5% to Forex

Umang Gupta — Thu, 23 Apr 2026 07:17:30 +0000

Published April 16, 2026
·
By MoltPe Team

Indian freelance AI developers can accept international payments in USDC via MoltPe, skipping PayPal's 4–5% combined fees and forex spread entirely. Setup takes five minutes, gas fees are zero on Polygon PoS and Base, and you convert to INR only when you need rupees — not every time a client pays.

The Freelance Payment Tax Nobody Talks About

If you are an Indian AI developer earning ₹2 lakh per month from international clients, there is a good chance you are losing ₹8,000 to ₹10,000 of that every month to fees you barely see. Not to taxes. Not to tools. To the rails that move your money.

A typical PayPal invoice: a US client pays you $2,500. PayPal takes 4.4% as a cross-border transaction fee — $110 gone instantly. Then PayPal converts USD to INR at its own exchange rate, typically 2–3% worse than the mid-market rate. On a $2,400 conversion, that spread is another ₹4,000 to ₹6,000 silently shaved off. Effective loss: 5–6% before the money reaches your bank.

Over a year of steady freelance income at ₹2 lakh per month, that is roughly ₹1 lakh to ₹1.2 lakh evaporating into payment rails. A month's earnings. An entire trip. A good GPU. Gone because you accepted the default.

Wise is better — roughly 0.5–1% per transfer — but still takes 1–3 business days and requires your client to set up a Wise account. Many US and EU clients default to PayPal because their accounting team already has PayPal set up, and you wear the cost.

SWIFT wire transfers are the worst: $15–40 in intermediary fees, another bank cut on the inbound, unfavorable conversion rates, and 2–5 working days. If you have ever received a SWIFT of $1,000 and seen ₹79,000 arrive instead of the expected ₹83,000, that is where the ₹4,000 went.

Most Indian freelancers treat these losses as a fixed cost of doing international business. They are not. In 2026, stablecoins changed that.

Why AI Devs Are the Perfect Fit for USDC

AI and ML is one of the most borderless skill sets in the world. Your client base is almost never exclusively Indian. If you are building LangChain pipelines, fine-tuning models, wiring up RAG systems, or shipping agent applications, your buyers are global by default.

Your revenue is dollar-denominated whether you like it or not. When you accept PayPal and it hands you rupees, what is really happening is: you earned dollars, PayPal converted them down to rupees, and your real negotiating unit got lost in the process.

There is also a less obvious point. AI developers spend in dollars too — OpenAI API credits, Anthropic API, Replicate, RunPod, Vercel, Supabase, GitHub Copilot, domain names, Cloudflare. If you receive rupees and then spend on dollar-priced tools, you pay the forex tax twice: once on the way in, once on the way out. Holding USDC lets you pay your OpenAI bill directly from the same dollars your client sent you, with no round trip through INR.

What USDC Actually Changes

USDC is a stablecoin pegged 1:1 to the US dollar, issued by Circle, a regulated US company. It is not a speculative asset. It is dollars that happen to move on blockchain rails instead of SWIFT rails.

The shift for an Indian freelancer is about optionality. When your client pays you in USDC, you are holding dollars. You decide when and how much to convert to INR — this week, next month, half now and half later. You are no longer forced to convert 100% of your income on the day it arrives at whatever rate PayPal offers.

Fee savings are immediate. A $2,500 payment that would have cost $125 via PayPal costs $0 via USDC on Polygon PoS or Base. The client sends $2,500, your wallet shows $2,500. You convert to INR when you need it through an Indian exchange, at a rate much closer to the mid-market rate.

Longer term: pay your OpenAI bill directly in USDC, stack dollar savings when INR is weakening, invoice in USD natively without asking your client to use Wise, and accept micro-payments from international clients without a $1 fixed fee eating a $10 invoice.

None of this removes the need to pay Indian taxes on your income. USDC income is still income. But you get to decide the timing and the path, and you keep the 5% that used to belong to PayPal.

Setup Guide: From Zero to First USDC Payment

Step 1: Create a MoltPe Wallet. Sign up at moltpe.com/dashboard. No credit card. No approval queue. Roughly 30 seconds — email, password, done. Create a wallet named "freelance-inbound" and save the wallet address (share with clients) and wallet ID (for API use).

MoltPe wallets are non-custodial. The private key is split using Shamir secret sharing — no single party, including MoltPe, ever holds the complete key. You control your funds without managing raw private keys yourself.

Step 2: Share Your Address or Create a Payment Link.

Option A: Paste your wallet address into your invoice. Tell the client to send USDC on Polygon PoS or Base. Most US startups and Web3 shops will do this without friction.
Option B: Generate a MoltPe payment link from the dashboard with a pre-filled amount — the client clicks the link, pays through their preferred on-ramp, and the payment arrives in your wallet. Friendlier for first-time crypto payers.

Step 3: Client Sends USDC. Transactions on Polygon PoS and Base confirm in under 5 seconds. Your dashboard balance updates as soon as the transaction is mined. MoltPe covers gas fees on Polygon PoS, Base, and Tempo — the full invoiced amount lands in your wallet.

Step 4: Convert to INR When You Need It. Send USDC from your MoltPe wallet to an Indian crypto exchange (CoinDCX, WazirX — compare their spreads before picking). Sell USDC for INR and withdraw to your bank via IMPS or NEFT. Typical end-to-end: 1–4 hours. Effective conversion rate much closer to the mid-market rate than PayPal.

Realistic workflow: a US client sends you $2,000 USDC on Thursday afternoon. It lands in your wallet in under 10 seconds. You convert $1,000 to INR for monthly obligations. Next month your OpenAI bill arrives — you pay $200 directly from your USDC balance, no forex round-trip. The remaining $800 stays as a dollar reserve.

Important: Indian tax law applies to USDC income. Consult a Chartered Accountant familiar with crypto income before you file.

Real-World Patterns: Three Freelancers

These are illustrative composites, not real individuals.

Priya, Bangalore-based LangChain consultant. Three US retainer clients paying a combined $8,000 per month. On PayPal she was losing roughly $400 per month (~₹33,000 per year). She switched to USDC invoicing — two clients moved over immediately, the third uses Wise. She converts about 60% of incoming USDC to INR monthly and holds the rest as a dollar buffer for AWS and OpenAI spending.

Arjun, Hyderabad indie dev. Builds small AI tools — Stripe for credit-card customers, direct USDC invoicing for enterprise deals above $3,000. He uses the same wallet for x402 API monetization on one of his tools, so a fraction of revenue is now fully machine-to-machine with zero invoicing overhead.

Neha, Pune ML engineer. Full-time day job, moonlights on Upwork. Upwork pays her to Wise (she cannot change that). But when clients move off-platform for long-term work, she invoices them directly in USDC. New clients through Upwork, established clients direct in USDC.

Frequently Asked Questions

Do I need to declare USDC income in my ITR?

Yes. Income received as USDC is taxable under Indian law regardless of whether it lands in a bank account or a crypto wallet. The fair value in INR at the time of receipt is what you declare. Gains when you later convert to INR may be subject to additional tax under Virtual Digital Asset provisions. Consult a Chartered Accountant who has handled crypto income before filing.

Is this better than Wise for freelancers?

For pure fee comparison, yes. Wise takes roughly 0.5–1% per transfer plus a less-favorable rate, and transfers take 1–3 business days. USDC via MoltPe settles in seconds with zero platform fees and zero gas fees. The trade-off: Wise deposits INR directly to your bank, while USDC requires one additional step when you want rupees. If you spend some income in dollars anyway (API credits, cloud, subscriptions), USDC is strictly better. If every rupee needs to hit your bank immediately, Wise is simpler.

Can I use this if I work through Upwork, Toptal, or Contra?

For platform-mediated work, the platform controls payout — USDC is not currently a payout option on most talent platforms. Where USDC via MoltPe shines is direct client relationships: retainers, contract work sourced through LinkedIn, your own network, GitHub sponsors, or returning clients. Many Indian freelancers use platforms to find the first project, then move long-term clients off-platform to direct invoicing in USDC.

What is the minimum amount worth accepting in USDC?

There is no hard minimum — MoltPe charges zero gas fees on Polygon PoS, Base, and Tempo, so a $5 payment lands with the full $5 intact. The break-even where USDC beats PayPal is any amount above zero. The practical minimum depends on the Indian exchange's withdrawal thresholds, typically around ₹500–1000. For micro-payments, hold USDC and convert in batches.

Originally published at https://moltpe.com/blog/freelance-ai-developer-payments-india. MoltPe is AI-native payment infrastructure that gives AI agents isolated wallets with programmable spending policies for autonomous USDC transactions. Get started free

USDC Payments for Indian Developers: The 2026 Guide

Umang Gupta — Thu, 23 Apr 2026 07:15:31 +0000

Published April 16, 2026
·
By MoltPe Team

USDC is a US-dollar stablecoin that Indian developers can receive directly for international work, avoiding PayPal's 4–5% fees, unfavorable forex spreads, and SWIFT settlement delays. Payments settle in seconds on Polygon PoS or Base, the received amount stays dollar-denominated until you choose to convert, and every transfer is programmable by code.

The Indian Developer Payment Problem

If you are an Indian developer, freelancer, or small SaaS founder invoicing international clients in 2026, you already know the problem. Every rupee that finally lands in your bank account has passed through at least two tollbooths: a payment processor and a foreign exchange conversion.

PayPal charges Indian receivers around 4% to 5% in combined transaction fees for cross-border payments. Stripe India faces onboarding restrictions for certain AI and developer tool categories. Razorpay International can accept global payments, but USD to INR conversion still happens on the banking leg. Wire transfers via SWIFT take two to five business days.

Concrete math: you invoice a US client for USD 1,200. On PayPal, around INR 4,000 to 5,000 disappears in transaction fees plus another 2% to 3% in forex spread. For a freelancer doing USD 2,000 per month in international work, that is roughly INR 10,000 to INR 15,000 per month going into processing — the price of a decent laptop or three months of SaaS runway.

What Is USDC and Why It Helps

USDC (USD Coin) is a stablecoin issued by Circle, a US-regulated financial technology company. Each USDC is backed 1:1 by US dollars held in regulated reserves, and Circle publishes monthly attestation reports. One USDC equals one US dollar. Always.

For an Indian developer, three properties matter most: USDC is dollar-denominated (no forex on the inbound leg), settles in seconds on Polygon PoS and Base, and through platforms like MoltPe it is gasless — no MATIC or ETH needed separately.

USDC vs Razorpay vs Stripe vs PayPal vs SWIFT

Feature	USDC via MoltPe	Razorpay International	Stripe India	PayPal International	SWIFT Wire
Transaction fee	0% platform fee on free tier	~3% + GST	~3% + INR 2	~4%–5%	Flat (INR 500–2,000 each leg)
Forex loss	None on inbound	~1%–2% bank spread	~1%–2% bank spread	~2%–3% internal rate	~1%–2% bank spread
Settlement time	Seconds	T+2 to T+3	T+3 to T+7	Instant to 21-day holds	2–5 business days
AI-agent-native	Yes (MCP + x402 supported)	No	Limited	No	No

How to Accept USDC in India with MoltPe

Step 1: Create a MoltPe wallet. Sign in at moltpe.com/dashboard — free tier, no upfront payment, no gas token management, non-custodial.

Step 2: Share your wallet address or a payment link. Share your USDC wallet address on Polygon PoS or Base. Or generate a MoltPe payment link for non-technical clients.

Step 3: Programmatic receive via REST API.

curl -X GET https://api.moltpe.com/v1/payments?direction=received&limit=10 \
  -H "Authorization: Bearer YOUR_API_KEY"

To construct a payment link programmatically:

curl -X POST https://api.moltpe.com/v1/payment-links \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"amount": "1200.00", "currency": "USDC", "chain": "polygon", "memo": "Invoice #INV-2026-041"}'

Converting USDC to INR

Indian exchanges that support USDC include CoinDCX, WazirX, ZebPay, and Bitbns. Before depositing, confirm which network the exchange expects. Once you sell USDC for INR, the transaction becomes a Virtual Digital Asset disposal event under Indian tax law. Talk to a Chartered Accountant who has handled VDA filings before you start.

Who Benefits Most

Indian freelance AI developers and ML engineers — USDC eliminates the PayPal tax, keeping an extra 4% to 7% per invoice
Bootstrapped AI SaaS startups — lower fees mean the difference between hiring and not hiring at USD 3,000–20,000 MRR
Indian consultants with global clients — faster settlement, lower forex losses
Open source maintainers — receive from corporate sponsors without intermediary cuts

Frequently Asked Questions

Is it legal to accept USDC in India?

Indian law treats USDC as a Virtual Digital Asset (VDA) under the Income Tax Act. Receiving USDC for services is not prohibited but is subject to specific tax rules. Consult a qualified CA familiar with VDA rules before you start.

Which Indian exchanges support USDC?

CoinDCX, WazirX, ZebPay, and Bitbns, among others. Always verify current status on the exchange itself, confirm the deposit network matches where you are sending USDC from, and complete KYC first.

Can I receive USDC without a crypto exchange account?

Yes. A MoltPe wallet is non-custodial and requires no exchange account. You only need an exchange when you want to convert USDC to INR.

What is the difference between USDT and USDC?

Both are US dollar stablecoins pegged 1:1. USDC is issued by Circle with monthly independent attestations. For business payments where auditability matters, many Indian developers prefer USDC.

Originally published at https://moltpe.com/blog/usdc-payments-india-developers. MoltPe is AI-native payment infrastructure that gives AI agents isolated wallets with programmable spending policies for autonomous USDC transactions. Get started free

AI Agent Payments in India: The 2026 Developer Guide

Umang Gupta — Thu, 23 Apr 2026 07:05:02 +0000

Published April 16, 2026 · By MoltPe Team

AI agent payments are autonomous USDC transactions that your AI service or tool executes on its own — no card swipes, no manual invoices. For Indian developers, they unlock global billing without Stripe India restrictions, skip 4–5% forex drag on PayPal, and settle in seconds. MoltPe gives every agent an isolated wallet with programmable spending policies, live from the India free tier.

India's AI Moment

India is now the second-largest pool of AI developers on the planet. Bangalore alone runs more working AI startups per square kilometer than most countries have in total. Walk through HSR Layout or Koramangala on a Friday evening and you will find hackathons, demo nights, and builder meetups where agent frameworks, vector databases, and open-source LLM forks get shipped in real time. Hyderabad's HITEC City has become a hub for AI infrastructure work. Pune's Baner and Kharadi corridors host a growing wave of indie AI studios. Chennai's OMR stretch is producing a steady pipeline of AI SaaS companies. The talent density is real and the output is accelerating.

The signals are hard to miss. Indian contributors now make up one of the top two cohorts on GitHub globally, and AI repositories out of India routinely clear 10k stars in their first quarter. Y Combinator's recent batches have featured more India-founded AI companies than any previous year. Hackathon velocity is at an all-time high — a single weekend in 2026 can produce a dozen production-ready agents, voice pipelines, and retrieval systems that would have taken a team six months to build in 2022.

What changed is that the underlying models got cheap, the tooling got mature, and the go-to-market got direct. An indie builder in Whitefield can now ship an AI SaaS product that serves customers in San Francisco, Berlin, and Tokyo from the first day. The only remaining friction is the money layer — and that is where 2026 becomes a turning point.

What Are AI Agent Payments?

AI agent payments are transactions initiated, authorized, and settled by autonomous AI systems — not by humans tapping approve. The agent holds its own wallet, checks the requested payment against a programmable spending policy, signs the transaction, and submits it on-chain. In a typical MoltPe flow, the entire cycle clears in under a second on Polygon PoS, Base, or Tempo, and the settlement happens in USDC stablecoins.

Three concrete examples:

An agent calls a paid API that responds with HTTP 402 Payment Required. The agent's wallet signs a USDC payment, attaches it to the retry header, and gets the data back — no billing portal, no API key rotation, no monthly invoice.
An agent needs 200 MB of premium training data. It queries its balance, confirms the purchase is within its daily policy limit, pays the data provider, and the dataset streams back.
An agent running customer support charges the end customer per resolved ticket. Each resolution triggers an outbound invoice, and settlement happens automatically.

Why India Needs This Infrastructure Now

The cross-border payment problem for Indian developers is not new. What is new is that agent-driven workloads make the old rails completely unworkable.

PayPal takes a 4–5% bite. Between the currency conversion spread, the withdrawal fee, and the intermediate bank charge, an Indian freelancer invoicing a US client in dollars typically loses four to five percent of each payment.

SWIFT wires take 2–5 business days. That is fine for a monthly retainer. It is useless for an agent that needs to pay a data provider mid-query to continue processing a user request.

Stripe India restrictions. Stripe's India entity operates under RBI guidance that restricts certain cross-border flows, limits supported business categories, and adds onboarding friction that can delay go-live by weeks.

Card processing adds 2–3% plus GST. Razorpay, PayU, and CCAvenue all work well for domestic INR flows, but when billing a global customer in USD for a per-API-call AI service, the economics are brutal.

Here is the opportunity: Indian developers already enjoy world-class engineering at cost structures that make aggressive pricing sustainable. When you remove the 4–5% forex tax and multi-day settlement delay, "global market, Indian pricing" becomes the default.

How Indian Developers Use MoltPe

Pattern 1: AI SaaS charging per-call in USDC. An indie founder in HSR builds a specialized AI agent — say, a legal-document summarizer tuned for Indian contract law. Instead of a monthly subscription, every API call costs 0.05 USDC. Settlement is instant. Revenue lands the same second the work gets done.

Pattern 2: Agent tools that pay for resources autonomously. A mid-stage AI startup in Pune runs a research agent that needs to buy data, spin up compute, and call other agents' APIs. With MoltPe, the agent has its own isolated wallet funded with USDC, spending policies cap daily outflow at $50 per agent, and the agent handles every purchase within those rules.

Pattern 3: Freelance AI devs receiving project payments without forex loss. A senior ML engineer in Bangalore consults for a European client. Instead of PayPal (4–5% gone) or a bank wire (days of delay), the client funds a MoltPe wallet and releases USDC on milestone completion.

Get Started in India — 3 Steps

Step 1: Sign up. Visit moltpe.com/dashboard and create an account. The basic tier has no KYC friction for developer experimentation.

Step 2: Fund with USDC. Send USDC to your agent's wallet address on Polygon PoS, Base, or Tempo. Gas on supported chains is zero.

Step 3: Set spending policies. Set a daily limit, a per-transaction cap, and optionally a recipient allowlist. Start conservative — a 10 USDC daily limit is plenty for initial testing.

Frequently Asked Questions

What are AI agent payments, simply put?
AI agent payments are transactions where the AI itself initiates, authorizes, and settles the payment. The agent holds its own wallet, checks a spending policy, and sends USDC on-chain in under a second.

Are AI agent payments legal in India?
USDC is generally treated as a Virtual Digital Asset (VDA) under Indian tax law. MoltPe is payment infrastructure — not tax or legal advice. Before running commercial flows, consult a chartered accountant familiar with VDA rules.

Which AI frameworks work with MoltPe from India?
Anything that can make HTTP calls or run an MCP server. MoltPe ships native integrations for Claude Desktop, Cursor, and Windsurf via MCP, supports the x402 protocol, and exposes a REST API for LangChain, LlamaIndex, CrewAI, AutoGen, and any custom agent.

Do I need an international bank account to use MoltPe in India?
No. MoltPe wallets are funded in USDC. You only touch INR when you decide to off-ramp.

How much does it cost for Indian developers?
The MoltPe free tier costs nothing — wallet creation, spending policy configuration, and zero gas fees at no charge.

Originally published at https://moltpe.com/blog/ai-agent-payments-india-guide. MoltPe gives AI agents isolated wallets with programmable spending policies for autonomous USDC transactions. Get started free

AI Agent Payments in India: The Complete Infrastructure Guide (2026)

Umang Gupta — Thu, 16 Apr 2026 15:40:11 +0000

MoltPe gives Indian developers, freelancers, and AI startups dollar-denominated agent wallets that receive and send USDC globally with zero forex fees, zero gas fees, and sub-second settlement. No foreign entity required, no credit card to start, no minimum balance. Use it alongside UPI and Razorpay for a complete domestic plus international payment stack.

Table of Contents

Why This Matters for India
How MoltPe Solves It for Indian Builders
MoltPe vs Razorpay International vs Stripe India vs PayPal
Use Cases for Indian Builders
How It Works in Three Steps
Related Guides
Frequently Asked Questions

Why This Matters for India

India has one of the world's largest and fastest growing AI developer populations. Bangalore, Hyderabad, Pune, Chennai, and Delhi NCR are producing a new generation of builders who write code in English, ship to global customers, and compete at the frontier of agent systems, retrieval-augmented generation, and automation tooling. The talent is here. The ambition is here. The payments infrastructure is not.

The friction shows up the moment an Indian builder tries to collect international revenue or pay a foreign service provider. PayPal typically takes around 4 to 5 percent on cross-border receipts, plus a forex spread on the INR conversion. SWIFT wires are slow, manual, and expensive per transaction, which makes them useless for anything under a few hundred dollars. Stripe India operates under restrictions that do not apply in the US or the UK. Razorpay International runs on top of the same legacy forex rails and still imposes a conversion spread. Every one of these options was built for a world where payments were initiated by humans, cleared by correspondent banks, and measured in days.

AI agent payments live in a different world. An agent making two hundred micropayments a day to different paid APIs cannot tolerate a four percent fee stack. A freelancer in Hyderabad billing a client in San Francisco does not want to wait three to five business days and lose money to forex each time. An AI SaaS founder in Bangalore charging per API call in small amounts needs settlement in seconds, not T plus two.

USDC via MoltPe routes around the legacy stack entirely. USDC is a dollar-denominated stablecoin. The value never touches the SWIFT or card networks in transit. Your Indian clients, international clients, and AI agents transact directly against on-chain dollar balances, and your wallet is yours. There is no correspondent bank in the middle, no forex conversion at the platform layer, and no three-to-five-day settlement window. This is the infrastructure that the next decade of Indian AI and SaaS builders need, and it is available right now.

How MoltPe Solves It for Indian Builders

MoltPe is AI-native payment infrastructure that gives AI agents isolated wallets with programmable spending policies for autonomous USDC stablecoin transactions. Every agent gets its own non-custodial wallet secured with Shamir key splitting, which means no single party, including MoltPe, ever holds a complete private key. Your funds are yours, cryptographically, from the moment the wallet is created.

For Indian developers, the combination of features matters more than any single one:

Dollar-denominated balances. Your agent wallet holds USDC. You hold dollars until you choose to convert. No more watching a rupee-denominated balance shrink as the dollar strengthens mid-month.
Zero forex fees at the platform level. When a client in New York or London or Singapore pays your agent wallet, they transfer USDC. You receive USDC. Nothing is converted on the way in. You only touch forex when and if you decide to convert to INR later, on a venue of your choosing.
Zero gas fees on supported chains. MoltPe covers gas on Polygon PoS, Base, and Tempo. A two-dollar micropayment costs two dollars, not two dollars plus a thirty cent network fee.
Sub-second settlement. Payments clear on chain in roughly 500 milliseconds. Compare this to PayPal holds, SWIFT delays, or card network settlement windows.
Programmable spending policies. Set a daily cap, a per-transaction cap, a recipient allowlist, and a cooldown period.
AI-agent-native interfaces. REST API, Model Context Protocol server, and x402 support out of the box.
Free tier, no credit card, no gating. An indie developer in Chennai can create an agent wallet in under five minutes.
Works from any country. No India-specific restriction, no US-entity requirement.

MoltPe is the layer Indian AI builders deserve.

See the full guide at https://moltpe.com/india for complete comparison tables, use cases, FAQs, and integration steps.

Originally published at https://moltpe.com/india. MoltPe is AI-native payment infrastructure that gives AI agents isolated wallets with programmable spending policies for autonomous USDC transactions. Get started free →

How to Add Payments to Your AI Agent: Step-by-Step Tutorial

Umang Gupta — Thu, 16 Apr 2026 12:52:31 +0000

MoltPe enables developers to integrate autonomous USDC payments into AI agents in under five minutes. This tutorial walks you through every step — from wallet creation to your first payment.

Prerequisites

Before starting, you'll need:

A free MoltPe account (no credit card required)
An AI agent or LLM environment capable of making API calls
USDC funding on Polygon PoS, Base, or Tempo (even $1 works for testing)

The platform handles wallet creation, key management, and transaction signing behind the scenes.

Step 1: Create an Agent Wallet

Each agent needs an isolated, non-custodial wallet:

Sign up at moltpe.com/dashboard
Click "Create Wallet" and give it a descriptive name
Select your preferred network (Polygon PoS, Base, or Tempo)
Record your wallet address and wallet ID

The system uses Shamir secret sharing to split private keys, ensuring no single party holds complete key access.

Step 2: Fund Your Wallet and Set Policies

Deposit USDC: Send stablecoins to your wallet address. No minimum required. Gas fees are covered by MoltPe on supported chains.

Configure Spending Policies: Set guardrails enforced at the infrastructure level:

daily_limit_usdc: Maximum 24-hour spending (e.g., $50)
per_transaction_cap_usdc: Individual transaction limit (e.g., $10)
cooldown_seconds: Minimum time between transactions
allowed_recipients: Optional allowlist of recipient addresses

Only the wallet owner can modify policies; agents cannot override them.

Step 3: Connect Your Agent

Option A: MCP Server

Add configuration to your LLM environment's settings file:

{
  "mcpServers": {
    "moltpe": {
      "command": "npx",
      "args": ["-y", "@moltpe/mcp-server"],
      "env": {
        "MOLTPE_API_KEY": "your-api-key-here",
        "MOLTPE_WALLET_ID": "your-wallet-id-here"
      }
    }
  }
}

After restarting, your agent gains access to payment tools: check_balance, send_payment, and list_transactions.

Option B: REST API

Standard HTTP endpoints for custom agents:

Check balance:

GET https://api.moltpe.com/v1/wallet/balance
Headers: Authorization: Bearer YOUR_API_KEY
         X-Wallet-ID: YOUR_WALLET_ID

Send payment:

POST https://api.moltpe.com/v1/wallet/send
Body: {"to": "0x...", "amount_usdc": "2.50", "memo": "..."}

Responses include transaction IDs and policy violation details.

Option C: x402 Protocol

Enables automatic payment at the HTTP level:

Agent makes standard API request to x402-enabled service
Server responds with 402 Payment Required status
MoltPe wallet automatically pays and retries the request
Server delivers the requested resource

Payments are invisible to agent logic. Spending policies still apply.

Testing Your Integration

Verify Balance: Confirm your agent can read wallet balance accurately
Send Test Payment: Submit a small transaction and verify it appears in your dashboard
Test Policy Enforcement: Deliberately trigger policy violations to confirm they're blocked
Review History: Check transaction records in the dashboard

Common Issues and Fixes

Issue	Solution
Insufficient balance error	Verify USDC was sent to correct network
Policy rejection	Check daily spending and per-transaction limits
Wrong network	Ensure API calls match wallet's configured network
MCP tools not appearing	Restart LLM environment and verify JSON syntax

FAQ

Setup time: Under five minutes from signup to first payment.

Code requirements: MCP requires only JSON configuration. x402 requires no custom code. REST API requires standard HTTP integration code.

Testing without real funds: Use demo.moltpe.com or deposit as little as $1 USDC (zero gas fees on supported chains).

Running out of funds: Agent receives an insufficient balance error. No overdrafts possible. Wallet can be topped up anytime through the dashboard.

Originally published at moltpe.com/blog/how-to-add-payments-to-ai-agent

x402 Protocol: Complete Guide to HTTP-Native Micropayments

Umang Gupta — Thu, 16 Apr 2026 12:50:33 +0000

The x402 protocol brings payments directly into HTTP using the long-dormant 402 status code. This guide covers everything developers need to know about implementing HTTP-native micropayments for AI agents and APIs.

What Is the x402 Protocol?

The x402 protocol is an open standard that enables payments directly within HTTP using the 402 Payment Required status code. Originally reserved in the 1999 HTTP/1.1 specification, this status code remained unused for over two decades until x402 provided a concrete implementation for machine-to-machine payments.

x402 was designed specifically for software agents buying things from other software agents — eliminating account creation, payment method entry, and redirect flows typical of traditional systems.

Key characteristics:

No pre-registration required — clients can pay any server on first contact
Machine-readable by default — the entire flow occurs through HTTP headers
Per-request granularity — enables true micropayments from fractions of a cent to dollars

How x402 Works

The payment process follows five sequential steps:

Client Requests Resource — sends a standard HTTP request
Server Responds 402 — returns payment requirements via headers (amount, token, network, recipient, expiry)
Client Signs and Submits Payment — constructs a blockchain transaction and resubmits the request with payment proof
Server Verifies On-Chain — validates transaction settlement
Server Delivers Resource — returns HTTP 200 with requested content

Response headers include:

X-Payment-Amount
X-Payment-Token
X-Payment-Network
X-Payment-Recipient
X-Payment-Expiry

x402 vs Traditional Payment APIs

Dimension	Traditional APIs	x402
Authentication	API keys, OAuth, session cookies	Payment proof in HTTP header
Payment Flow	Multi-step with manual setup	Two HTTP requests
Settlement	Days to weeks	Seconds via blockchain
Fees	2.9% + $0.30 per transaction	Fraction of a cent in gas
Machine-Readable	Partially, requires SDK	Fully, standardized headers
Setup Complexity	High, requires KYC, PCI compliance	Low, wallet address plus headers
Micropayments	Impractical, ~$0.50 minimum	Native, viable at $0.001+

Code Examples

cURL Implementation

# Step 1: Initial request
curl -i https://api.example.com/v1/premium-data

# Response includes:
# X-Payment-Amount: 1000
# X-Payment-Token: 0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359
# X-Payment-Network: polygon
# X-Payment-Recipient: 0x8f2e...c9E2
# X-Payment-Expiry: 1713312000

# Step 2: Retry with proof after on-chain payment
curl -i https://api.example.com/v1/premium-data \
  -H "X-Payment-Proof: 0xabc123..."

JavaScript/Node.js

async function x402Fetch(url, options = {}) {
  const initialResponse = await fetch(url, options);

  if (initialResponse.status !== 402) {
    return initialResponse;
  }

  const paymentAmount = initialResponse.headers.get("X-Payment-Amount");
  const paymentToken = initialResponse.headers.get("X-Payment-Token");
  const paymentNetwork = initialResponse.headers.get("X-Payment-Network");
  const paymentRecipient = initialResponse.headers.get("X-Payment-Recipient");
  const paymentExpiry = initialResponse.headers.get("X-Payment-Expiry");

  if (Date.now() / 1000 > parseInt(paymentExpiry)) {
    throw new Error("Payment window expired, retry to get new terms");
  }

  const txHash = await submitPayment({
    to: paymentRecipient,
    amount: paymentAmount,
    token: paymentToken,
    network: paymentNetwork,
  });

  const paidResponse = await fetch(url, {
    ...options,
    headers: {
      ...options.headers,
      "X-Payment-Proof": txHash,
    },
  });

  return paidResponse;
}

const response = await x402Fetch("https://api.example.com/v1/premium-data");
const data = await response.json();

Python

import time
import requests

def x402_request(url, method="GET", **kwargs):
    response = requests.request(method, url, **kwargs)

    if response.status_code != 402:
        return response

    payment_requirements = {
        "amount": response.headers.get("X-Payment-Amount"),
        "token": response.headers.get("X-Payment-Token"),
        "network": response.headers.get("X-Payment-Network"),
        "recipient": response.headers.get("X-Payment-Recipient"),
        "expiry": response.headers.get("X-Payment-Expiry"),
    }

    if time.time() > int(payment_requirements["expiry"]):
        raise ValueError("Payment window expired")

    tx_hash = submit_payment(
        to=payment_requirements["recipient"],
        amount=payment_requirements["amount"],
        token=payment_requirements["token"],
        network=payment_requirements["network"],
    )

    headers = kwargs.pop("headers", {})
    headers["X-Payment-Proof"] = tx_hash

    paid_response = requests.request(
        method, url, headers=headers, **kwargs
    )
    return paid_response

response = x402_request("https://api.example.com/v1/premium-data")
data = response.json()

Integrating x402 with MoltPe

MoltPe supports x402 natively with automatic payment handling:

Automatic 402 detection and header extraction
Policy-checked signing before payment
Gasless settlement (sponsored gas on Polygon PoS, Base, Tempo)
Automatic retry with payment proof

MCP Tool Call

{
  "tool": "call_x402_endpoint",
  "arguments": {
    "url": "https://api.example.com/v1/premium-data",
    "method": "GET",
    "max_payment": "0.01"
  }
}

REST API

POST https://api.moltpe.com/v1/x402/proxy
Authorization: Bearer YOUR_AGENT_TOKEN
Content-Type: application/json

{
  "target_url": "https://api.example.com/v1/premium-data",
  "method": "GET",
  "max_payment_usd": "0.01"
}

MoltPe agents can also collect payments by configuring as sellers, with automatic 402 header generation and on-chain verification.

Use Cases

API Monetization

Servers can charge for access without managing API keys or billing infrastructure, using x402 as the sole access control mechanism.

Data Marketplace

Agents pay exactly for what they use, and providers earn exactly for what they serve — enabling economically viable niche data sales.

Agent-to-Agent Services

Specialized agents can charge other agents for services — translation, code review, market analysis — without invoicing overhead.

Content Paywalls

Publishers can charge per-article instead of requiring subscriptions, appealing to both humans and agents accessing content across multiple providers.

FAQ

What does x402 stand for?
The protocol references HTTP status code 402 (Payment Required), with "x" indicating experimental status.

Is x402 a blockchain protocol?
x402 is an HTTP-layer protocol that uses blockchain for payment settlement. It remains network-agnostic and compatible with EVM-compatible chains.

Who created x402?
Coinbase pioneered the specification and reference implementation, which has since gained adoption across multiple platforms.

Can x402 handle large payments?
Yes — there are no protocol-level limits. Payment amounts are server-specified via headers.

How does x402 compare to Lightning Network?
Lightning operates as a Layer 2 payment channel network on Bitcoin, while x402 operates at the HTTP layer on EVM chains using stablecoins like USDC.

Originally published at moltpe.com/blog/x402-protocol-complete-guide

What Are AI Agent Payments? Complete Guide (2026)

Umang Gupta — Thu, 16 Apr 2026 12:44:10 +0000

AI agent payments represent a paradigm shift in how autonomous systems handle financial transactions. Rather than requiring human intervention for each transaction, AI systems can now independently manage funds through isolated wallets while adhering to programmable spending boundaries. Platforms like MoltPe provide the infrastructure enabling these autonomous transactions to settle in stablecoins with minimal latency and zero blockchain fees.

The Rise of Autonomous AI Transactions

The payments landscape experienced dramatic transformation in 2025. Stablecoin transaction volume exceeded $33 trillion, surpassing traditional card networks. Major financial institutions recognized this shift: Visa launched stablecoin infrastructure, Stripe acquired Bridge for $1.1 billion, and Coinbase deployed agent-compatible USDC systems.

The underlying driver is straightforward. Contemporary AI agents already execute complex financial tasks—booking travel, provisioning cloud resources, accessing paid APIs, and managing software subscriptions. Yet today's systems typically force agents into one of two suboptimal positions: returning transactions to the user for approval or relying on pre-authorized tokens with inadequate spending controls.

Agent payment infrastructure closes this gap. It enables autonomous systems to maintain fund balances, evaluate transaction costs, and execute payments within owner-defined parameters.

How AI Agent Payments Work

An agent payment follows a predictable sequence:

TASK RECEIVED - Agent receives instruction to complete a spending-related task
WALLET CHECK - Agent queries its isolated wallet balance
POLICY EVALUATION - Agent verifies transaction complies with daily limits, per-transaction caps, and recipient restrictions
PAYMENT EXECUTION - Agent signs an EIP-712 typed transaction and submits USDC transfer
SETTLEMENT CONFIRMED - On-chain confirmation occurs within ~500ms

Each step operates automatically without requiring callbacks, approval workflows, or stored financial credentials. The agent's wallet contains only allocated operational funds, while spending policies function as automated safeguards replacing traditional human review.

Traditional Payments vs Agent Payments

Dimension	Traditional Payments	AI Agent Payments
Initiation	Human approval required	Autonomous, policy-driven
Speed	2-5 business days	Sub-second finality
Fees	2-3% interchange + processing	Zero gas fees (supported chains)
Limits	Card limits, issuer-set caps	Programmable daily limits, per-transaction caps
Settlement	T+1 to T+3	Instant, on-chain, verifiable

Key Protocols Powering Agent Payments

x402: HTTP-Native Micropayments

The x402 protocol repurposes the HTTP 402 status code as a functional payment mechanism. When an agent calls a paid API, servers respond with 402 Payment Required including pricing details. The agent's wallet automatically constructs a USDC payment signature, includes it in the request header, and retries the call.

MPP: Machine Payments Protocol

MPP standardizes machine-to-machine payment discovery, negotiation, and execution. It handles service pricing discovery, volume discount negotiation, and payment routing across blockchains.

MCP: Model Context Protocol

MCP enables large language models to interact with payment infrastructure through standardized interfaces. MoltPe's MCP server allows LLMs running in Claude Desktop, Cursor, or Windsurf to check balances, send payments, and review transaction history through natural language commands.

Why Spending Policies Matter

Granting agent access to funds without spending controls introduces unnecessary risk:

Runaway loops - Agents encountering retry patterns purchase identical resources hundreds of times
Price manipulation - Malicious APIs increase prices mid-session
Prompt injection - Attackers craft inputs instructing agents to transfer funds
Scope creep - Agents acquire resources outside their mandate

MoltPe agent wallets support configurable policies enforcing rules at the infrastructure level:

Daily spending limits - Cap 24-hour total outflows
Per-transaction caps - Reject payments exceeding thresholds
Recipient allowlists - Restrict payments to pre-approved addresses
Cooldown periods - Enforce minimum intervals between transactions

Getting Started in 5 Minutes

Step 1: Create an Agent Wallet

Access moltpe.com to create a new agent wallet. Each wallet operates independently with its own balance and spending policies. Wallets employ non-custodial architecture via Shamir key splitting.

Step 2: Fund It and Set Policies

Transfer USDC to your agent's wallet on Polygon PoS, Base, or Tempo. Configure spending policies: daily limits, per-transaction maximums, and optionally restrict payable addresses.

Step 3: Connect Your Agent

MCP - For Claude Desktop, Cursor, or Windsurf
x402 - For automatic payment handling on paid APIs
REST API - For custom agents with any language/framework

FAQ

What are AI agent payments?
Financial transactions initiated, authorized, and completed by autonomous AI systems without requiring human approval each time. Agents maintain isolated wallets and settle in USDC stablecoins.

How do AI agents make payments without human approval?
Agents operate within owner-defined spending policies. Transactions within guardrails execute autonomously. Transactions exceeding limits are automatically rejected.

Is it secure?
MoltPe employs non-custodial Shamir key splitting, AES-256-GCM encryption, TLS 1.3, and EIP-712 typed signatures. Spending policies enforce limits at the infrastructure level.

How much does it cost?
MoltPe provides a free tier including wallet creation, spending policies, and zero gas fees on Polygon PoS, Base, and Tempo. No platform fees or setup costs.

Originally published at moltpe.com

DEV Community: Umang Gupta

x402 Protocol for Indian Developers: Monetize APIs in USDC (2026)

Why Indian API Builders Should Care

How x402 Works — The Protocol

Code: Expose a Paid API Endpoint

Code: Consume a Paid API From an Agent

Indian Use Cases

Frequently Asked Questions

What programming languages work with x402?

Do my Indian API users need to know crypto?

How much per-call revenue can realistically flow through x402?

Is x402 production-ready?

How does x402 compare to subscription billing for Indian SaaS?

Related Articles

The Complete Payments Infrastructure Stack for Indian AI Startups in 2026

Why Payment Infrastructure Matters More for AI Startups

Layer 1: Domestic Fiat (Razorpay / Cashfree / UPI)

Layer 2: International (MoltPe + USDC)

Layer 3: Agent-to-Agent (MoltPe + x402/MPP)

Integration Architecture

Common Mistakes Indian AI Startups Make

Frequently Asked Questions

What is the minimum startup size where this three-layer stack makes sense?

Do we need to be registered outside India to accept USDC payments?

Can we use MoltPe alongside our existing Razorpay setup?

How does MoltPe compare to Stripe for Indian AI startups?

Related Articles

How Freelance AI Developers in India Get Paid in 2026 Without Losing 5% to Forex

The Freelance Payment Tax Nobody Talks About

Why AI Devs Are the Perfect Fit for USDC

What USDC Actually Changes

Setup Guide: From Zero to First USDC Payment

Real-World Patterns: Three Freelancers

Frequently Asked Questions

Do I need to declare USDC income in my ITR?

Is this better than Wise for freelancers?

Can I use this if I work through Upwork, Toptal, or Contra?

What is the minimum amount worth accepting in USDC?

Related Articles

USDC Payments for Indian Developers: The 2026 Guide

The Indian Developer Payment Problem

What Is USDC and Why It Helps

USDC vs Razorpay vs Stripe vs PayPal vs SWIFT

How to Accept USDC in India with MoltPe

Converting USDC to INR

Who Benefits Most

Frequently Asked Questions

Is it legal to accept USDC in India?

Which Indian exchanges support USDC?

Can I receive USDC without a crypto exchange account?

What is the difference between USDT and USDC?

Related Articles

AI Agent Payments in India: The 2026 Developer Guide

India's AI Moment

What Are AI Agent Payments?

Why India Needs This Infrastructure Now

How Indian Developers Use MoltPe

Get Started in India — 3 Steps

Frequently Asked Questions

AI Agent Payments in India: The Complete Infrastructure Guide (2026)

Why This Matters for India

How MoltPe Solves It for Indian Builders

How to Add Payments to Your AI Agent: Step-by-Step Tutorial

Prerequisites

Step 1: Create an Agent Wallet

Step 2: Fund Your Wallet and Set Policies

Step 3: Connect Your Agent

Option A: MCP Server

Option B: REST API

Option C: x402 Protocol

Testing Your Integration

Common Issues and Fixes

FAQ

x402 Protocol: Complete Guide to HTTP-Native Micropayments

What Is the x402 Protocol?

How x402 Works

x402 vs Traditional Payment APIs

Code Examples

cURL Implementation

JavaScript/Node.js