Send payouts, on the rail that gets there first.

Quick start

Send your first payout in three steps.

https://api.primefastpay.com/v1

Base URLs by environment

Authentication

Authenticate every request with your secret API key in the Authorization header. Keys are environment-scoped: use test keys for sandbox, live keys for production.

Authorization: Bearer sk_live_xxxxxxxx

API key types

Payment methods

Choose the method per payout — Prime Fast Pay doesn't lock you into one rail.

All fees are deducted from the payout amount unless you opt for sender-bears-cost in your dashboard settings.

Create a payout

Initiate a payout to a recipient. Funds are disbursed according to the selected method.

Headers

Body parameters

curl -X POST https://api.primefastpay.com/v1/payouts \
  -H "Authorization: Bearer sk_live_xxxxxxxx" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $(uuidgen)" \
  -d '{
    "amount": 250000,
    "currency": "USD",
    "recipient_id": "rec_9x8y7z6w5v4u",
    "method": "rtp",
    "description": "Invoice #4421",
    "metadata": {
      "invoice_id": "4421",
      "project": "website-redesign"
    }
  }'

{
  "id": "pay_1a2b3c4d5e6f",
  "object": "payout",
  "amount": 250000,
  "currency": "USD",
  "status": "completed",
  "method": "rtp",
  "recipient_id": "rec_9x8y7z6w5v4u",
  "description": "Invoice #4421",
  "metadata": {
    "invoice_id": "4421",
    "project": "website-redesign"
  },
  "estimated_arrival": "2026-08-11T12:22:15Z",
  "created_at": "2026-08-11T12:22:10Z",
  "completed_at": "2026-08-11T12:22:15Z"
}

Retrieve a payout

Fetch a single payout by its ID.

Path parameters

curl https://api.primefastpay.com/v1/payouts/pay_1a2b3c4d5e6f \
  -H "Authorization: Bearer sk_live_xxxxxxxx"

List payouts

Returns a paginated list of payouts. Filter by status, method, date range, or recipient.

Query parameters

curl "https://api.primefastpay.com/v1/payouts?status=completed&limit=20" \
  -H "Authorization: Bearer sk_live_xxxxxxxx"

Cancel a payout

Cancel a payout that has not yet been submitted to the banking network. Once processing or completed, cancellation is impossible.

curl -X POST https://api.primefastpay.com/v1/payouts/pay_1a2b3c4d5e6f/cancel \
  -H "Authorization: Bearer sk_live_xxxxxxxx"

{
  "error": {
    "type": "payout_not_cancellable",
    "message": "This payout has already been submitted to the network and cannot be canceled."
  }
}

Create a recipient

Store a recipient's payout details securely. Prime Fast Pay tokenizes sensitive data — you never handle raw account numbers after creation.

Body parameters

curl -X POST https://api.primefastpay.com/v1/recipients \
  -H "Authorization: Bearer sk_live_xxxxxxxx" \
  -H "Content-Type: application/json" \
  -d '{
    "type": "individual",
    "name": "John Doe",
    "email": "john@example.com",
    "bank_account": {
      "routing_number": "021000021",
      "account_number": "000123456789",
      "account_type": "checking"
    },
    "address": {
      "line1": "123 Main St",
      "city": "New York",
      "state": "NY",
      "postal_code": "10001",
      "country": "US"
    }
  }'

{
  "id": "rec_9x8y7z6w5v4u",
  "object": "recipient",
  "type": "individual",
  "name": "John Doe",
  "email": "john@example.com",
  "status": "verified",
  "created_at": "2026-08-11T12:22:10Z"
}

Retrieve a recipient

curl https://api.primefastpay.com/v1/recipients/rec_9x8y7z6w5v4u \
  -H "Authorization: Bearer sk_live_xxxxxxxx"

List recipients

Query parameters

Receiving webhooks

Subscribe to real-time events by registering an HTTPS endpoint. Prime Fast Pay signs every payload with a secret so you can verify authenticity.

Webhook signature

Each request includes a PrimeFastPay-Signature header:

PrimeFastPay-Signature: t=1723381330,v1=sha256=abc123def456...

Verify by computing the HMAC-SHA256 of timestamp.payload with your webhook secret and comparing to v1.

const crypto = require('crypto');

function verifyWebhook(payload, signature, secret) {
  const [t, v1] = signature.split(',').map(s => s.split('=')[1]);
  const signed = crypto.createHmac('sha256', secret)
    .update(`${t}.${payload}`)
    .digest('hex');
  return crypto.timingSafeEqual(
    Buffer.from(signed), Buffer.from(v1)
  );
}

Event types

All events follow the pattern resource.action.

AI agent integrations

The Prime Fast Pay MCP server exposes every endpoint in this reference as a tool. Any agent framework that speaks MCP can drive the API — no glue code, no per-SDK adapters. Install the wrapper once, point your agent at it, and let the model call the API.

Install the MCP wrapper

cargo install prime-fast-pay-mcp

The wrapper reads your API key from the environment and streams tool calls over stdio. Set it once before launching your agent:

export PRIME_FAST_PAY_API_KEY=sk_live_xxxxxxxx

Claude Agent SDK

The Anthropic Claude Agent SDK runs Claude as an autonomous agent with access to MCP servers, file tools, and sub-agents. Use it when you want a managed agent loop without orchestrating prompts yourself.

pip install claude-agent-sdk

import asyncio
from claude_agent_sdk import query, ClaudeAgentOptions

async def main():
    options = ClaudeAgentOptions(
        mcp_servers={
            "prime-fast-pay": {
                "command": "prime-fast-pay-mcp",
                "env": {"PRIME_FAST_PAY_API_KEY": "sk_live_xxxxxxxx"}
            }
        },
        allowed_tools=["mcp__prime-fast-pay__*"],
        system_prompt="You send payouts. Always confirm the recipient, amount, and method before calling create_payout."
    )
    async for message in query(
        prompt="Pay John Doe (rec_9x8y7z6w5v4u) $250 via RTP for invoice #4421.",
        options=options
    ):
        if message["type"] == "result":
            print(message["result"])

asyncio.run(main())

LangChain

LangChain loads MCP tools through langchain-mcp-adapters and runs them through a LangGraph React agent. Use this when you're already building on LangChain or LangGraph and want a single tool list across MCP and LangChain-native tools.

pip install langchain langchain-anthropic langchain-mcp-adapters langgraph

import asyncio
from langchain_mcp_adapters.client import MultiServerMCPClient
from langchain_anthropic import ChatAnthropic
from langgraph.prebuilt import create_react_agent

async def main():
    client = MultiServerMCPClient({
        "prime-fast-pay": {
            "command": "prime-fast-pay-mcp",
            "transport": "stdio",
            "env": {"PRIME_FAST_PAY_API_KEY": "sk_live_xxxxxxxx"}
        }
    })
    tools = await client.get_tools()
    model = ChatAnthropic(model="claude-opus-4-8")
    agent = create_react_agent(model, tools)
    result = await agent.ainvoke({
        "messages": [("user", "Pay John Doe (rec_9x8y7z6w5v4u) $250 via RTP for invoice #4421.")]
    })
    print(result["messages"][-1].content)

asyncio.run(main())

Google ADK

Google's Agent Development Kit ships an McpToolset that loads MCP tools into a Gemini-powered agent. Use it when you're building on Vertex AI or want Gemini as the reasoning engine.

pip install google-adk

import asyncio
from google.adk.agents import LlmAgent
from google.adk.tools.mcp_tool import McpToolset, StdioServerParameters
from google.adk.runners import Runner
from google.adk.sessions import InMemorySessionService
from google.genai import types

async def main():
    tools = McpToolset(
        connection_params=StdioServerParameters(
            command="prime-fast-pay-mcp",
            env={"PRIME_FAST_PAY_API_KEY": "sk_live_xxxxxxxx"}
        )
    )
    agent = LlmAgent(
        model="gemini-2.5-flash",
        name="payout_agent",
        instruction="You send payouts. Always confirm the recipient, amount, and method before calling create_payout.",
        tools=[tools],
    )
    session_service = InMemorySessionService()
    runner = Runner(agent=agent, app_name="prime-fast-pay", session_service=session_service)
    session = await session_service.create_session(
        app_name="prime-fast-pay", user_id="user_123", session_id="session_456"
    )
    content = types.Content(
        role="user",
        parts=[types.Part(text="Pay John Doe (rec_9x8y7z6w5v4u) $250 via RTP for invoice #4421.")]
    )
    async for event in runner.run_async(
        user_id="user_123", session_id="session_456", new_message=content
    ):
        if event.is_final_response():
            print(event.content.parts[0].text)

asyncio.run(main())

CrewAI

CrewAI orchestrates role-based agents that collaborate on tasks. Use MCPServerAdapter from crewai-tools to wire Prime Fast Pay tools into any agent or crew — no custom tool classes required.

pip install crewai crewai-tools

from crewai import Agent, Task, Crew, Process, LLM
from crewai_tools import MCPServerAdapter

mcp_tools = MCPServerAdapter({
    "prime-fast-pay": {
        "command": "prime-fast-pay-mcp",
        "env": {"PRIME_FAST_PAY_API_KEY": "sk_live_xxxxxxxx"}
    }
})

agent = Agent(
    role="Payout Specialist",
    goal="Send payouts accurately and confirm delivery.",
    backstory="You are an expert at managing outbound payments via Prime Fast Pay.",
    tools=mcp_tools,
    llm=LLM(model="anthropic/claude-opus-4-8"),
    verbose=True,
)

task = Task(
    description="Pay John Doe (rec_9x8y7z6w5v4u) $250 via RTP for invoice #4421. Return the payout ID.",
    expected_output="A short confirmation containing the payout ID returned by create_payout.",
    agent=agent,
)

crew = Crew(agents=[agent], tasks=[task], process=Process.sequential)
print(crew.kickoff())

Error codes

Errors return an error object with type, message, and optionally code and param.

{
  "error": {
    "type": "bad_request",
    "message": "Invalid routing number.",
    "code": "invalid_routing_number",
    "param": "bank_account.routing_number"
  }
}