INTEGRATIONS

Plug Blockchain0x into your agent stack.

Working integrations for every popular agent framework. One snippet plus an environment variable.

Pick your framework. Each integration is a drop-in tool, function, or middleware that you wire into your existing agent code. No SDK lock-in; the underlying API works without our tools too.

Each framework card below opens its own deep-dive: install commands, a working agent example, webhook handling, common pitfalls, and a link to the GitHub starter repo. All ten integrations are live.

SUPPORTED FRAMEWORKS

10 frameworks, one API.

LangChain

Drop-in BlockchainOxPaymentTool for ReAct and LangGraph agents

Read the guide

CrewAI

Payment tool for any CrewAI agent or task

Read the guide

AutoGen

Tool function for AutoGen multi-agent conversations

Read the guide

LlamaIndex

Tool spec for LlamaIndex ReAct and OpenAI agents

Read the guide

OpenAI Agents SDK

Native tool for OpenAI's agents SDK runs

Read the guide

Pydantic AI

Strongly-typed tool for Pydantic AI agents

Read the guide

LangGraph

Node-level payment integration for LangGraph workflows

Read the guide

Semantic Kernel

Plugin for Microsoft Semantic Kernel agents

Read the guide

Agno

Tool for Agno (formerly Phidata) agents

Read the guide

MCP servers

Middleware for Claude Desktop, Cursor, Cline, and any MCP server

Read the guide

See setup snippets in the docs

WHAT EVERY INTEGRATION INCLUDES

A consistent shape across every framework.

A drop-in tool, function, or middleware appropriate to the framework
A working starter repository on GitHub
A 60-word answer to 'how do I add payments to my {framework} agent'
FAQ entries with HowTo/FAQ schema for AI search engines
A link to the matching long-tail landing page
A link to the pricing page

ARCHITECTURE

Every integration is a thin wrapper over the same API.

The Blockchain0x integrations are not 10 separate products. They are 10 different ergonomic surfaces on top of a single HTTP API. The API is the source of truth; the framework wrappers exist to save you time.

  +---------------+   +-------------+   +-----------+   +-----------+   +----------------+
  | LangChain     |   | CrewAI      |   | AutoGen   |   | LlamaIndex|   | Pydantic AI    |
  | wrapper       |   | wrapper     |   | wrapper   |   | tool spec |   | wrapper        |
  +-------+-------+   +------+------+   +-----+-----+   +-----+-----+   +-------+--------+
          |                  |                |               |                 |
          +-----------+------+--------+-------+---------+-----+----+------------+
                      |               |                 |          |
                      v               v                 v          v
                              +-------------------------------+
                              | Blockchain0x HTTP API (v1)    |
                              |                               |
                              | POST /v1/payment-requests     |
                              | GET  /v1/payment-requests/:id |
                              | POST /v1/agents               |
                              | GET  /v1/agents/:id           |
                              | GET  /v1/transactions         |
                              +---------------+---------------+
                                              |
                                              v
                              +-------------------------------+
                              | Chain adapter (Base, MVP)     |
                              | USDC ledger + spend policy    |
                              +-------------------------------+

Each framework wrapper translates from "the way your framework asks you to define a tool" into "an HTTP request to our API". That is the entire job. The LangChain wrapper exposes a BlockchainOxPaymentTool class because that is what LangChain agents expect. The CrewAI wrapper exposes a @tool-decorated function because that is what CrewAI agents expect. Both call POST /v1/payment-requests under the hood with the same JSON body.

This matters for a few reasons. First, you can mix and match: a LangChain production agent and a CrewAI experimental agent can both target the same Blockchain0x agent wallet without conflict. Second, you are not locked into a framework choice through us; switching frameworks does not require any change to your wallet, your spend policies, or your public page. Third, when we ship a new endpoint or a new webhook event, the framework wrappers expose it on their next release; the underlying API is the contract.

SKIP THE SDK

You can integrate without our SDK, our wrapper, or our framework integration.

The Blockchain0x API is plain JSON over HTTPS with bearer-token auth. Any HTTP client in any language can call it. The official SDKs and framework wrappers are convenience layers; the raw API is documented, stable, and intentionally small enough that hand-writing against it is reasonable.

CURL - NO SDK

curl -X POST https://api.blockchain0x.com/v1/payment-requests \
  -H "Authorization: Bearer $BLOCKCHAIN0X_KEY" \
  -H "Idempotency-Key: $(uuidgen)" \
  -H "Content-Type: application/json" \
  -d '{
    "agent_id":  "agt_01J9...",
    "amount_usdc": "5.00",
    "reason":      "Custom market analysis",
    "callback_url": "https://my-agent.com/webhooks/payment"
  }'

When skipping the SDK makes sense

You are in a language we do not ship. Go, Rust, Elixir, Ruby, PHP, Java - all of these can call our API natively with their standard HTTP libraries. No special tooling required.
You are on the edge. Cloudflare Workers, Vercel Edge Functions, Deno Deploy - environments where you would rather not bundle an extra dependency. The raw API works there without changes.
You want to see exactly what is on the wire. For debugging, security review, or learning the protocol, the raw HTTP shape is clearer than reading SDK source.
You have your own HTTP layer with retries, logging, telemetry. Bringing in another SDK with its own retry behavior fights your existing infrastructure. Calling the raw API as just another HTTP endpoint slots in cleanly.

The full API reference at docs.blockchain0x.com includes the OpenAPI spec, so you can also generate your own client in any language that has an OpenAPI codegen tool.

PICKING A FRAMEWORK

When each framework is the right tool.

If you have not picked an agent framework yet, here is how we see the trade-offs. None of these are wrong choices; the right one depends on what your agent does and who maintains it.

Framework	Best when	Avoid when
LangChain	Existing LangChain codebase, complex tool chains, broad ecosystem use	You want minimal dependencies; LangChain pulls in a lot
LangGraph	Stateful multi-step workflows, durable execution, human-in-the-loop	Simple linear chains; the graph overhead is wasted
CrewAI	Multi-agent collaboration patterns (researcher + writer + reviewer)	Single-agent loops; CrewAI is built for crews
AutoGen	Multi-agent conversation, group chat patterns, Microsoft tooling	Production high-throughput; AutoGen optimizes for research
LlamaIndex	RAG-heavy agents, document Q+A as core capability	Pure tool-use agents; LlamaIndex's strengths go unused
OpenAI Agents SDK	OpenAI-only stacks, want the cleanest tool-use API	Multi-provider stacks; OpenAI SDK is OpenAI-centric
Pydantic AI	Strong typing across all agent inputs/outputs, Python-first	TypeScript-first stacks; the Python-native typing is the value
Semantic Kernel	Existing .NET / C# / Java codebase, enterprise Microsoft shop	Python-only teams; you are paying for unused MS integration
Agno	Python-native, lightweight, want minimal abstraction overhead	You need the LangChain ecosystem's third-party integrations
MCP middleware	You are running an MCP server and want clients to pay per call	You are not running an MCP server (it is a server-side pattern)

Two practical pieces of advice. If you are starting from scratch and want the smallest possible learning curve, LangChain or OpenAI Agents SDK are the safest defaults. If you already have a framework, our integration for it works fine; do not switch frameworks just to use Blockchain0x.

DEEPER GUIDES

Specific scenarios get their own page.

Beyond the framework-specific integration pages, we publish long-tail guides on narrower questions: "how do I add payments to a LangGraph multi-step workflow", "how do I let my MCP server charge per tool", "how do I gate a Stripe-like API behind USDC payment". These live at /lp/{slug} and are intentionally not in the main navigation. They get found through search; each links back to the relevant integration page.

Where to find them

The first batch of long-tail guides ships alongside the integration framework pages. Until then, the most concrete scenario-specific content lives in the docs at docs.blockchain0x.com under "Guides". Each /lp/ page on launch includes working code, a starter repository link, and a direct CTA to upgrade the relevant agent to Pro.

FREQUENTLY ASKED

Five integration questions worth answering.

If the SDK is optional, why does it exist at all?

Three reasons. First, ergonomics: the SDK auto-generates idempotency keys, types every request and response, and bundles webhook signature verification so you do not write that code yourself. Second, drift protection: when we add an endpoint or change a field, the next SDK release exposes it; raw HTTP users need to read the changelog. Third, instrumentation: the SDK auto-emits structured logs and metrics in a format compatible with common observability stacks. None of these are essential, but they save 30-90 minutes of integration time. If you would rather see the raw shape of the API, skip the SDK and use curl or any HTTP client.

I am using a framework you do not list. Can I still integrate?

Yes. Every framework integration is built on top of the same public HTTP API: five endpoints, signed webhooks, bearer-token auth. If you can speak HTTP and HMAC-SHA256, you can integrate from any framework, including ones we have not published a wrapper for. The integration pages exist for convenience, not for gatekeeping. If you want us to add an official integration for your framework, open an issue on github.com/blockchain0x and we will assess based on community demand.

Can one agent be served by multiple framework integrations at once?

Yes. A single agent has one wallet address, one set of API keys, one spend policy, and one public page. Different parts of your stack can call our API through different framework integrations: a LangChain agent in production, a CrewAI experiment, an MCP server middleware, all paying the same agent or all charging through the same agent. The framework boundary is on your side; we just see authenticated API requests and webhook subscriptions.

Do the framework integrations cost extra?

No. The framework integrations (npm packages, PyPI packages, MCP middlewares) are MIT-licensed and free. The cost is the per-agent subscription plus transaction fees you would pay regardless. You pay the same to integrate via the official LangChain wrapper as you would calling our HTTP API directly with curl. The wrapper exists to save you time, not to gate functionality.

How quickly do you update integrations when frameworks ship breaking changes?

We target a release within 7 days of a major version of any supported framework (LangChain 1.x to 2.x, OpenAI Agents SDK breaking changes, etc.). Minor versions usually require no SDK change because we wrap stable interfaces. Subscribe to the GitHub repo for the relevant integration to get release notes in your inbox. If a framework's breaking change makes our integration unsafe, we publish a deprecation notice on the matching /integrations/{framework}/ page before pulling support.

Plug it in, start getting paid.

Free to start. Five minutes to your first payment request.