Developer Documentation

# In your N8N directory
npm install n8n-nodes-agnicwallet

# Or use N8N Community Nodes
# Settings → Community Nodes → Install → "n8n-nodes-agnicwallet"

{
  "authentication": "oAuth2",
  "method": "POST",
  "url": "https://api.example.com/x402-endpoint",
  "body": {
    "prompt": "Generate a summary"
  }
}

[Schedule Trigger: Every 1 hour]
    ↓
[AgnicWallet X402 Request]
  → URL: https://api.example.com/generate
  → Method: POST
  → Body: {"prompt": "Daily news summary"}
    ↓
[Save to Database]
    ↓
[Send Email with Results]

// 1. Add MCP Client node configuration
{
  "serverType": "HTTP/SSE",
  "serverUrl": "https://mcp.agnicpay.xyz/sse",
  "authHeader": "Authorization: Bearer agnic_tok_sk_live_..."
}

// 2. Use the make_x402_request tool
{
  "tool": "make_x402_request",
  "parameters": {
    "url": "https://api.example.com/data",
    "method": "POST",
    "body": {
      "prompt": "Generate a summary"
    }
  }
}

// The MCP server handles payment automatically!

from langchain.tools import BaseTool
import requests

class AgnicWalletTool(BaseTool):
    name = "make_payment"
    description = "Make a payment to an X402 API and get the response"

    def _run(self, url: str, method: str = "POST", body: dict = None):
        # Step 1: Try initial request
        response = requests.request(method, url, json=body)

        if response.status_code != 402:
            return response.text

        # Step 2: Sign payment - pass the FULL 402 response
        # The 402 response contains all required X402 fields
        payment_requirements = response.json()

        sign_response = requests.post(
            'https://api.agnicpay.xyz/api/sign-payment',
            headers={
                'X-Agnic-Token': 'YOUR_TOKEN_HERE',
                'Content-Type': 'application/json'
            },
            json={
                'paymentRequirements': payment_requirements,
                'requestData': {'url': url, 'method': method}
            }
        )

        if not sign_response.ok:
            return f"Payment failed: {sign_response.text}"

        # Step 3: Retry with payment proof
        final_response = requests.request(
            method, url, json=body,
            headers={'X-Payment': sign_response.json()['paymentHeader']}
        )

        return final_response.text

# Use in your agent
from langchain.agents import initialize_agent
from langchain.llms import OpenAI

tool = AgnicWalletTool()
agent = initialize_agent(
    [tool],
    OpenAI(temperature=0),
    agent="zero-shot-react-description"
)

result = agent.run("Call the AI API to summarize quantum computing")

async function callX402Api(url, options = {}) {
  const { method = 'POST', body = null } = options;
  const token = 'YOUR_TOKEN_HERE';

  // Step 1: Initial request
  let response = await fetch(url, {
    method,
    headers: { 'Content-Type': 'application/json' },
    body: body ? JSON.stringify(body) : null
  });

  if (response.status !== 402) {
    return await response.json();
  }

  // Step 2: Sign payment - pass the FULL 402 response
  // The 402 response contains all required X402 fields:
  // scheme, network, maxAmountRequired, maxTimeoutSeconds,
  // resource, description, mimeType, asset, payTo, extra
  const paymentRequirements = await response.json();

  const signResponse = await fetch('https://api.agnicpay.xyz/api/sign-payment', {
    method: 'POST',
    headers: {
      'X-Agnic-Token': token,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      paymentRequirements,  // Pass entire 402 response
      requestData: { url, method }
    })
  });

  if (!signResponse.ok) {
    throw new Error(\`Payment failed: \${await signResponse.text()}\`);
  }

  const { paymentHeader } = await signResponse.json();

  // Step 3: Retry with payment
  const final = await fetch(url, {
    method,
    headers: {
      'Content-Type': 'application/json',
      'X-Payment': paymentHeader
    },
    body: body ? JSON.stringify(body) : null
  });

  return await final.json();
}

// Usage
const result = await callX402Api('https://api.example.com/generate', {
  method: 'POST',
  body: { prompt: 'Explain quantum computing' }
});

import requests

class AgnicWalletClient:
    def __init__(self, token):
        self.token = token
        self.base_url = 'https://api.agnicpay.xyz'
        self.headers = {'X-Agnic-Token': token}

    def get_balance(self, network='base-sepolia'):
        """Check wallet USDC balance"""
        response = requests.get(
            f'{self.base_url}/api/balance',
            headers=self.headers,
            params={'network': network}
        )
        return response.json()

    def call_x402_api(self, url, method='POST', data=None):
        """Call X402-enabled API with automatic payment"""
        # Step 1: Initial request
        response = requests.request(method, url, json=data)

        if response.status_code != 402:
            return response.json()

        # Step 2: Sign payment - pass the FULL 402 response
        # The 402 response contains all required X402 fields:
        # scheme, network, maxAmountRequired, maxTimeoutSeconds,
        # resource, description, mimeType, asset, payTo, extra
        payment_requirements = response.json()

        sign_response = requests.post(
            f'{self.base_url}/api/sign-payment',
            headers={**self.headers, 'Content-Type': 'application/json'},
            json={
                'paymentRequirements': payment_requirements,
                'requestData': {'url': url, 'method': method}
            }
        )

        if not sign_response.ok:
            raise Exception(f"Payment failed: {sign_response.text}")

        payment_header = sign_response.json()['paymentHeader']

        # Step 3: Retry with payment
        final_response = requests.request(
            method, url, json=data,
            headers={'X-Payment': payment_header}
        )

        return final_response.json()

    def get_transactions(self, page=1, limit=10):
        """Get transaction history"""
        response = requests.get(
            f'{self.base_url}/api/transactions',
            headers=self.headers,
            params={'page': page, 'limit': limit}
        )
        return response.json()

# Usage
client = AgnicWalletClient(token='YOUR_TOKEN_HERE')

# Check balance before making payment
balance = client.get_balance()
print(f"Balance: {balance['usdcBalance']} USDC")

# Make payment
result = client.call_x402_api(
    url='https://api.example.com/generate',
    method='POST',
    data={'prompt': 'Explain quantum computing'}
)

# Review recent transactions
transactions = client.get_transactions(limit=5)
print(f"Recent transactions: {transactions['stats']['totalSpent']} USDC")