DEV Community

AgrentGatePay
AgrentGatePay

Posted on

Building Payment Infrastructure for AI Agents: Python + JavaScript + n8n (Technical Deep Dive)

#ai #web3 #agents #langchain

AI agents are becoming autonomous. But they're missing one critical capability: payments.

This is how we built AgentGatePay - payment infrastructure for the agent economy, with full support for both Python and JavaScript developer ecosystems.

The Problem

AI agents (LangChain, AutoGPT, Claude with MCP) can:

  • Research and synthesize information
  • Write code and debug
  • Interact with APIs
  • Make decisions autonomously

But when an agent needs to pay for something (data, APIs, compute), there's no good solution.

Why traditional payments don't work for agents:

  1. Require company registration (agents don't have companies)
  2. Need bank accounts (agents don't have bank accounts)
  3. Built for humans, not autonomous systems
  4. Slow settlement (2-7 days)
  5. High fees (2.9% + $0.30)

The Solution: Crypto-Native Agent Payments

1. Multi-Chain From Day One

  • Ethereum (security, decentralization)
  • Base (low fees, fast)
  • Polygon (scalability)
  • Arbitrum (L2 benefits)

Same API, different chains. Agent changes ?chain=base query param.

2. Budget Control (AP2 Protocol)

Agents need spending limits. We use mandate tokens:

# Issue mandate - cryptographic budget
mandate = client.mandates.issue(
    subject="agent@example.com",
    budget_usd=100,
    scope="research-api"
)
# Returns signed token
Enter fullscreen mode Exit fullscreen mode

Mandate token is cryptographically signed. Gateway verifies signature + checks budget on every payment.

3. Multiple Payment Flows

Client wallet mode (agent controls key):

# Agent signs transaction
tx = wallet.send_transaction(to=receiver, value=amount)
# Agent submits to gateway
payment = client.payments.submit_tx_hash(mandate_token, tx.hash)
Enter fullscreen mode Exit fullscreen mode

External TX signing (Docker service):

# Agent requests gateway to sign
payment = client.payments.submit_with_tx_service(
    mandate_token,
    receiver=merchant,
    amount_usd=1.00
)
Enter fullscreen mode Exit fullscreen mode

4. Framework Integrations

LangChain (20 examples - 10 Python + 10 JavaScript):

  • Basic payments (both languages)
  • Marketplace (buyer/seller agents - both languages)
  • Monitoring dashboards (both languages)
  • TX signing service (both languages)
  • Same examples, dual implementation - choose your language

Why both languages?

  • Python dominates data science and ML research
  • JavaScript dominates web/edge deployment (Vercel, Cloudflare Workers)
  • Different use cases require different stacks
  • We built native SDKs for both, not just wrappers

JavaScript ecosystem support:

  • Works with Vercel AI SDK
  • Compatible with LangChain.js
  • Any JavaScript AI framework

N8N (4 workflows):

  • Buyer agent (autonomous purchasing)
  • Seller API (accept payments)
  • Monitoring (spending/revenue)

MCP (15 tools):

  • Claude Desktop integration
  • Issue mandates, submit payments, check status

Technical Architecture

Stack:

  • Backend: AWS Lambda (Python 3.12), DynamoDB
  • Security: CloudFront + WAF, rate limiting, replay protection
  • Blockchain: ethers.js v6 (JavaScript), web3.py (Python)
  • SDKs: TypeScript, Python (both open source)
  • Gateway fee: 0.5% (transparent on-chain)

Payment Verification Flow:

  1. Agent executes blockchain transaction (USDC transfer)
  2. Agent submits tx_hash to gateway
  3. Gateway verifies on-chain (sender, receiver, amount, token)
  4. Gateway grants resource access if verified
  5. Webhook notification sent to merchant

Multi-Chain Abstraction:
Same code, different chains:

// Ethereum
const payment = await client.payments.submitTxHash(
  mandateToken, txHash, { chain: 'ethereum' }
);

// Base (same API!)
const payment = await client.payments.submitTxHash(
  mandateToken, txHash, { chain: 'base' }
);
Enter fullscreen mode Exit fullscreen mode

Adaptive Retry (Performance Optimization):

  • <$1 payments: Optimistic mode (4s total, background verification)
  • ≥$1 payments: Synchronous mode (56s max, fraud prevention)

Result: <$1 payments settle in 3-4s, ≥$1 in 10-56s (safe).

Code Examples

LangChain Payment Agent (Python) 

from agentgatepay_sdk import AgentGatePay

agp = AgentGatePay(api_url="https://api.agentgatepay.com")

# Issue mandate
mandate = agp.mandates.issue("agent@example.com", budget_usd=100)

# Execute blockchain transaction
tx_hash = execute_blockchain_tx(price)

# Submit to gateway
payment = agp.payments.submit_tx_hash(mandate['mandateToken'], tx_hash)

print(f"Payment verified: {payment['verified']}")
Enter fullscreen mode Exit fullscreen mode

LangChain Payment Agent (JavaScript) 

import { AgentGatePay } from 'agentgatepay-sdk';

const agp = new AgentGatePay({
  apiUrl: 'https://api.agentgatepay.com',
  apiKey: 'pk_live_...'
});

// Issue mandate
const mandate = await agp.mandates.issue('agent@example.com', 100);

// Execute blockchain transaction
const txHash = await executeBlockchainTx(price);

// Submit to gateway
const payment = await agp.payments.submitTxHash(mandate.mandateToken, txHash);

console.log(`Payment verified: ${payment.verified}`);
Enter fullscreen mode Exit fullscreen mode

Same functionality, different language. Choose what fits your stack.

N8N Workflow

  1. HTTP Request: Trigger on webhook
  2. AgentGatePay: Issue mandate
  3. Code: Execute blockchain transaction
  4. AgentGatePay: Submit payment
  5. If verified: Proceed to next step
  6. If failed: Send error notification

What's Next

Roadmap:

  1. More framework integrations (AutoGPT, CrewAI, expanding Vercel AI SDK examples)
  2. Additional JavaScript framework examples (Anthropic SDK, OpenAI Node.js)
  3. Fiat on-ramps (credit cards → crypto)
  4. More chains (Solana, Avalanche, Optimism)
  5. Account abstraction (gasless transactions)
  6. Payment streaming (pay-per-second)

Try It

Install (choose your language):

# JavaScript/TypeScript
npm install agentgatepay-sdk

# Python
pip install agentgatepay-sdk
Enter fullscreen mode Exit fullscreen mode

20 Examples (10 Python + 10 JavaScript): https://github.com/AgentGatePay/agentgatepay-examples

Open source: MIT license

⚠️ Beta status: No SLA/uptime guarantees. Read DISCLAIMER.md.

Conclusion

AI agents need payment infrastructure built FOR them, not adapted from traditional systems.

Crypto-native payments solve this:

  • No company/bank needed
  • Instant settlement
  • Global by default
  • Programmable

Why we built for both Python and JavaScript:

The AI ecosystem is split. Python dominates research and data science. JavaScript dominates production web deployments. We didn't want to choose - so we built native SDKs for both.

Whether you're building a research agent in Python or deploying an edge AI agent with Vercel, AgentGatePay has you covered.

We built AgentGatePay to enable the agent economy across all development ecosystems. Try it and let us know what you build!

Links:

Questions? Reply below or open a GitHub issue!

Top comments (0)