AI Agent Integration

Overview

Hedge Payments is purpose-built for the AI economy. Our API is designed from the ground up to work seamlessly with AI agents, chatbots, and autonomous systems, enabling them to handle payment transactions on behalf of users with minimal friction.

Whether you're building with Claude Code for development automation, using ChatGPT for customer service, or deploying autonomous agents with Codex, Hedge Payments provides the payment infrastructure you need.

Claude & Claude Code Integration

Hedge Payments works seamlessly with both Claude Desktop and Claude Code (the CLI for developers). Using the Model Context Protocol (MCP), Claude can create and manage payments directly, making it perfect for AI-assisted development and autonomous payment workflows.

Installation

# Install the Hedge Payments MCP server
npm install -g @hedgepayments/mcp-server

# Configure in your Claude Desktop config
# Location: ~/Library/Application Support/Claude/claude_desktop_config.json
{
  "mcpServers": {
    "hedge-payments": {
      "command": "hedge-mcp",
      "args": ["--api-key", "YOUR_API_KEY"]
    }
  }
}

Example Usage

Once configured, you can ask Claude to create payments naturally:

Available MCP Tools

ChatGPT Integration (Function Calling)

Enable ChatGPT to process payments using OpenAI's function calling feature.

Function Definition

const functions = [
  {
    name: "create_payment",
    description: "Create a payment request for a customer",
    parameters: {
      type: "object",
      properties: {
        amount: {
          type: "number",
          description: "Payment amount"
        },
        currency: {
          type: "string",
          description: "Three-letter currency code (e.g., USD, EUR)"
        },
        customerEmail: {
          type: "string",
          description: "Customer's email address"
        },
        description: {
          type: "string",
          description: "Payment description"
        }
      },
      required: ["amount", "currency", "customerEmail"]
    }
  }
]

// Use in chat completion
const response = await openai.chat.completions.create({
  model: "gpt-4",
  messages: messages,
  functions: functions,
  function_call: "auto"
})

Handling Function Calls

if (response.choices[0].message.function_call) {
  const functionCall = response.choices[0].message.function_call
  const args = JSON.parse(functionCall.arguments)

  if (functionCall.name === "create_payment") {
    // Call Hedge Payments API
    const payment = await hedge.payments.create({
      amount: args.amount,
      currency: args.currency,
      customerEmail: args.customerEmail,
      description: args.description
    })

    // Return result to ChatGPT
    messages.push({
      role: "function",
      name: "create_payment",
      content: JSON.stringify({
        success: true,
        paymentId: payment.id,
        paymentUrl: payment.url
      })
    })

    // Continue conversation with function result
    const secondResponse = await openai.chat.completions.create({
      model: "gpt-4",
      messages: messages
    })
  }
}

OpenAI Codex Integration

OpenAI Codex can interact with the Hedge Payments API just like any other REST API. The straightforward design of our API makes it perfect for code generation and automation with Codex.

Using Codex for Payment Integration

Simply provide Codex with your payment requirements and it will generate the integration code:

async function createPayment() {
  const response = await fetch('https://api.hedgepayments.com/api/payments', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer ' + process.env.HEDGE_API_KEY,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      amount: 50.00,
      currency: 'USD',
      customerEmail: 'user@example.com',
      description: 'Payment for service'
    })
  })
  return await response.json()
}

ChatGPT Actions (Custom GPTs)

Create a Custom GPT with Hedge Payments actions to build payment-enabled chatbots.

OpenAPI Schema

Import this OpenAPI schema in your Custom GPT configuration:

openapi: 3.0.0
info:
  title: Hedge Payments API
  version: 1.0.0
servers:
  - url: https://api.hedgepayments.com
paths:
  /api/payments:
    post:
      operationId: createPayment
      summary: Create a payment request
      security:
        - bearerAuth: []
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              required:
                - amount
                - currency
                - customerEmail
              properties:
                amount:
                  type: number
                currency:
                  type: string
                customerEmail:
                  type: string
                description:
                  type: string
      responses:
        '200':
          description: Payment created successfully
components:
  securitySchemes:
    bearerAuth:
      type: http
      scheme: bearer

AI Agent Use Cases

Best Practices for AI Integration

• 🔒 Secure API Keys:
  Never expose API keys in client-side code. Use server-side proxies or JWT tokens.
• ✅ User Confirmation:
  Always confirm payment details with the user before processing transactions.
• 💬 Clear Communication:
  Provide clear payment summaries including amount, currency, and description before creating payments.
• 🔔 Error Handling:
  Gracefully handle API errors and provide helpful messages to users.
• 📊 Logging:
  Log all payment transactions with metadata for auditing and troubleshooting.
• 🔄 Webhook Integration:
  Use webhooks to receive real-time payment status updates and keep your AI agent in sync.

Example Conversation Flow

Here's how a typical payment conversation might flow with an AI agent: