FADP — Fluid Agentic DeFi Protocol

The open HTTP payment protocol for AI agents.

Gate any API endpoint behind a crypto micropayment. AI agents pay automatically — no wallets to manage, no API keys to share, no invoices.

What is FADP?

FADP (Fluid Agentic DeFi Protocol) is an open HTTP payment protocol built on top of the standard 402 Payment Required status code. Any server can gate any endpoint. Any AI agent with a Fluid Wallet agent key pays automatically and gets access.

Agent hits gated endpoint
        ↓
Server returns 402 + X-FADP-Required: { amount, token, chain, payTo, nonce }
        ↓
Agent pays on-chain via Fluid Wallet (fwag_ key)
        ↓
Agent retries with X-FADP-Proof: { txHash, nonce, timestamp }
        ↓
Server verifies payment → unlocks resource ✅

vs x402

| Feature | x402 (Coinbase) | FADP (Fluid) | |---|---|---| | Tokens | USDC only | ETH, USDC, USDT, any ERC-20 | | Chains | Base only | Base, Ethereum, Solana, Injective | | Agent identity | Raw wallet address | Email + scoped agent key | | Spend limits | None | Per-tx + daily cap built in | | Approval flow | None | Owner email approval for large amounts | | Agent setup | Wallet + funds required | Just a fwag_ key | | Replay protection | Signature-based | Nonce-based | | Open spec | Yes | Yes |

Installation

npm install fluid-fadp

Server — Gate Any Endpoint

import express from 'express';
import { fadpGate } from 'fadp';

const app = express();

// Gate a premium endpoint — agents pay 0.01 USDC per request
app.use('/api/premium-data', fadpGate({
  amount: '0.01',
  token: 'USDC',
  chain: 'base',
  payTo: process.env.MY_WALLET_ADDRESS!,   // your Fluid Wallet address
  description: 'Premium market data API',
}));

app.get('/api/premium-data', (req, res) => {
  res.json({ data: 'secret alpha', paidBy: req.fadpPayment });
});

What the agent sees when not paying

HTTP 402
X-FADP-Required: {
  "version": "1.0",
  "amount": "0.01",
  "token": "USDC",
  "chain": "base",
  "payTo": "0xYourWalletAddress",
  "description": "Premium market data API",
  "nonce": "a3f8c2d1e4b5...",
  "expires": 1745000300,
  "verifyUrl": "https://fluidnative.com/v1/fadp/verify"
}

Client — Auto-Pay in Agents

import { fadpFetch } from 'fadp';

// Replace your normal fetch with fadpFetch
const fetch = fadpFetch({
  agentKey: process.env.FLUID_AGENT_KEY!,   // fwag_...
  maxAutoPayUsd: 5,                           // safety limit
});

// This automatically pays if the endpoint returns 402 FADP
const res = await fetch('https://anyserver.com/api/premium-data');
const data = await res.json();
// data = { data: 'secret alpha', ... }

With OpenAI Agents / LangChain

import { fadpFetch } from 'fadp';
import { FluidAgent } from 'fluid-wallet-agentkit';

const agent = new FluidAgent({ apiKey: process.env.FLUID_AGENT_KEY! });
const fetch = fadpFetch({ agentKey: process.env.FLUID_AGENT_KEY! });

// Now your agent can access any FADP-gated API on the internet
const res = await fetch('https://some-paid-api.com/data');

Next.js Middleware

// middleware.ts
import { fadpGate } from 'fadp';
import { NextRequest, NextResponse } from 'next/server';

export function middleware(req: NextRequest) {
  if (req.nextUrl.pathname.startsWith('/api/premium')) {
    // Manual FADP check for Next.js edge
    const proof = req.headers.get('x-fadp-proof');
    if (!proof) {
      return NextResponse.json(
        { error: 'Payment required', protocol: 'FADP/1.0' },
        {
          status: 402,
          headers: {
            'X-FADP-Required': JSON.stringify({
              version: '1.0',
              amount: '0.01',
              token: 'USDC',
              chain: 'base',
              payTo: process.env.MY_WALLET_ADDRESS!,
              nonce: crypto.randomUUID(),
              expires: Math.floor(Date.now() / 1000) + 300,
              verifyUrl: 'https://fluidnative.com/v1/fadp/verify',
            }),
          },
        }
      );
    }
  }
  return NextResponse.next();
}

Protocol Specification

Request Headers

| Header | Direction | Description | |---|---|---| | X-FADP-Required | Server → Agent | JSON payment challenge | | X-FADP-Proof | Agent → Server | JSON payment proof |

X-FADP-Required Schema

{
  version: "1.0";
  amount: string;       // e.g. "0.01"
  token: string;        // "USDC" | "ETH" | "USDT"
  chain: string;        // "base" | "ethereum" | "solana"
  payTo: string;        // wallet address
  description?: string; // shown to agent
  nonce: string;        // one-time use, prevents replay
  expires: number;      // unix timestamp
  verifyUrl?: string;   // payment verifier endpoint
}

X-FADP-Proof Schema

{
  txHash: string;          // on-chain transaction hash
  nonce: string;           // must match the challenge nonce
  timestamp: number;       // unix timestamp of payment
  agentKeyPrefix?: string; // first 12 chars of fwag_ key (for identification)
}

Verification Endpoint

POST https://fluidnative.com/v1/fadp/verify

{
  "txHash": "0xabc...",
  "payTo": "0xServerWallet",
  "amount": "0.01",
  "token": "USDC",
  "chain": "base",
  "nonce": "a3f8c2d1..."
}

Response:

{
  "verified": true,
  "txHash": "0xabc...",
  "amount": "0.01",
  "token": "USDC",
  "chain": "base",
  "from": "0xAgentWallet",
  "to": "0xServerWallet"
}

How to Get an Agent Key

1. Register at fluidnative.com
2. Go to fluidnative.com/agentic-keys
3. Create a key with pay scope
4. Set FLUID_AGENT_KEY=fwag_... in your agent's environment

Use Cases

• Data APIs — charge per query (market data, analytics, ML inference)
• Compute APIs — pay per inference, rendering, or processing job
• Agent-to-agent payments — agents paying other agents for services
• Metered APIs — rate limiting by payment instead of API keys
• Content paywalls — premium content unlocked by micropayment

Links

• Protocol spec: fluidnative.com/fadp
• Fluid Wallet: fluidnative.com
• Agent SDK: fluid-wallet-agentkit on npm
• GitHub: github.com/fluidbase9/fadp ⭐
• npm: npmjs.com/package/fadp

License

MIT © Fluid Wallet