# BlockRun — YOPO: You Only Pay for the Outcome

> Markdown mirror of DialtoneApp's public top-site detail page for `blockrun.ai`.

URL: https://dialtoneapp.com/top-sites/blockrun.ai/index.md
Canonical HTML: https://dialtoneapp.com/top-sites/blockrun.ai

## Summary

- Domain: `blockrun.ai`
- Website: https://blockrun.ai
- Description: machine payable | x402 | score 62 | purchase payment challenge | control wallet required
- Label: machine_payable
- Payment surface: x402
- Purchase boundary: payment_challenge
- Control boundary: wallet_required
- Rank: 157

## robots

~~~text
# As a condition of accessing this website, you agree to abide by the following
# content signals:

# (a)  If a Content-Signal = yes, you may collect content for the corresponding
#      use.
# (b)  If a Content-Signal = no, you may not collect content for the
#      corresponding use.
# (c)  If the website operator does not include a Content-Signal for a
#      corresponding use, the website operator neither grants nor restricts
#      permission via Content-Signal with respect to the corresponding use.

# The content signals and their meanings are:

# search:   building a search index and providing search results (e.g., returning
#           hyperlinks and short excerpts from your website's contents). Search does not
#           include providing AI-generated search summaries.
# ai-input: inputting content into one or more AI models (e.g., retrieval
#           augmented generation, grounding, or other real-time taking of content for
#           generative AI search answers).
# ai-train: training or fine-tuning AI models.

# ANY RESTRICTIONS EXPRESSED VIA CONTENT SIGNALS ARE EXPRESS RESERVATIONS OF
# RIGHTS UNDER ARTICLE 4 OF THE EUROPEAN UNION DIRECTIVE 2019/790 ON COPYRIGHT
# AND RELATED RIGHTS IN THE DIGITAL SINGLE MARKET.

# BEGIN Cloudflare Managed content

User-agent: *
Content-Signal: search=yes,ai-train=no
Allow: /

User-agent: Amazonbot
Disallow: /

User-agent: Applebot-Extended
Disallow: /

User-agent: Bytespider
Disallow: /

User-agent: CCBot
Disallow: /

User-agent: ClaudeBot
Disallow: /

User-agent: CloudflareBrowserRenderingCrawler
Disallow: /

User-agent: Google-Extended
Disallow: /

User-agent: GPTBot
Disallow: /

User-agent: meta-externalagent
Disallow: /

# END Cloudflare Managed Content

User-Agent: *
Allow: /
Disallow: /api/
Disallow: /admin/

User-Agent: GPTBot
Allow: /
Disallow: /api/
Disallow: /admin/

User-Agent: ChatGPT-User
Allow: /
Disallow: /api/
Disallow: /admin/

User-Agent: ClaudeBot
Allow: /
Disallow: /api/
Disallow: /admin/

User-Agent: Claude-Web
Allow: /
Disallow: /api/
Disallow: /admin/

User-Agent: anthropic-ai
Allow: /
Disallow: /api/
Disallow: /admin/

User-Agent: Google-Extended
Allow: /
Disallow: /api/
Disallow: /admin/

User-Agent: PerplexityBot
Allow: /
Disallow: /api/
Disallow: /admin/

User-Agent: Bytespider
Allow: /
Disallow: /api/
Disallow: /admin/

User-Agent: cohere-ai
Allow: /
Disallow: /api/
Disallow: /admin/

User-Agent: OAI-SearchBot
Allow: /
Disallow: /api/
Disallow: /admin/

User-Agent: Applebot-Extended
Allow: /
Disallow: /api/
Disallow: /admin/

Sitemap: https://blockrun.ai/sitemap.xml
Sitemap: https://blockrun.ai/sitemap-services.xml
~~~

## llms

~~~text
# BlockRun

> BlockRun is the pay-per-call AI gateway — 55+ models, live data, and code sandbox, settled in USDC from one wallet via the x402 protocol. No API keys, no accounts, no subscriptions.

BlockRun provides pay-per-request access to 55+ large language models (GPT-5, Claude Opus 4.7, Gemini, Grok 4/Imagine, DeepSeek, Kimi K2.6, Llama, Mistral, Cohere, Qwen, and more), image generation (DALL-E 3, ChatGPT Images 2.0 / gpt-image-2, gpt-image-1, Nano Banana, Grok Imagine), video generation (Grok Imagine Video, ByteDance Seedance 1.5 Pro / 2.0 Fast / 2.0 Pro), audio APIs, and real-time data services including neural web search (Exa), prediction markets (Predexon), and sandbox compute (Modal). AI agents pay with USDC on Base, Solana, or XRPL — no subscriptions, no API keys, no vendor lock-in.

## Traction (since Feb 2026)

- 6,000,000+ API calls served
- 1,431+ unique paying wallets
- $31,000+ USDC settled on-chain (Base treasury)
- Live public metrics: https://blockrun.ai/metrics

## Key Products

- [Franklin](https://franklin.run): Flagship agent — the ChatGPT of crypto, driven by BlockRun's gateway.
- [ClawRouter](https://github.com/BlockRunAI/ClawRouter): Open-source LLM router CLI that cuts API costs up to 78% via compression, intelligent routing, and caching. MIT licensed.
- [AI Model Gateway](https://blockrun.ai/models): Access 55+ LLMs from OpenAI, Anthropic, Google, xAI, DeepSeek, Moonshot, Meta, Mistral, Cohere, Alibaba via a single OpenAI-compatible endpoint.
- [Data Marketplace](https://blockrun.ai/partners): Neural web search (Exa), prediction markets (Predexon), sandbox compute (Modal).
- **On-chain Price Feeds** — realtime + historical prices for stocks, crypto, FX, and commodities:
  - **US Stocks** (975+ tickers, **$0.001 USDC per call** via x402): `GET /v1/usstock/price/AAPL`, `GET /v1/usstock/history/AAPL?resolution=D&from=<ts>&to=<ts>`. Sessions: `?session=pre|post|on`. Free list at `/v1/usstock/list`.
  - **Crypto** (500+ pairs, **FREE**): `GET /v1/crypto/price/BTC-USD`, `GET /v1/crypto/history/ETH-USD?resolution=D`. Free list at `/v1/crypto/list`.
  - **FX** (**FREE**): `GET /v1/fx/price/EUR-USD`. Free list at `/v1/fx/list`.
  - **Commodities** (**FREE**): `GET /v1/commodity/price/XAU-USD` (gold), `/v1/commodity/price/XAG-USD` (silver). Free list at `/v1/commodity/list`.
- [Claude Code Plugin / MCP Server](https://blockrun.ai/claude-code-plugin): Use BlockRun services directly from Claude Code, Cursor, and other MCP clients.

## For Developers

- Python SDK: `pip install blockrun-llm`
- TypeScript SDK: `npm install @blockrun/llm`
- Go SDK: `go get github.com/blockrunai/blockrun-llm-go`
- MCP Server: `claude mcp add blockrun --transport http https://mcp.blockrun.ai/mcp`

## How It Works

BlockRun uses the x402 protocol — an HTTP-native payment standard. When an AI agent makes an API request, BlockRun returns a 402 Payment Required response with the price. The agent signs a USDC payment locally (private key never leaves the agent's machine), retries the request with the payment header, and receives the response. Settlement is non-custodial and instant.

## Networks

- Base Mainnet (https://blockrun.ai) — production with real USDC
- Solana Mainnet (https://sol.blockrun.ai) — production with real USDC
- XRPL (https://xrpl.blockrun.ai) — production with real USDC
- Base Sepolia (https://testnet.blockrun.ai) — testnet with test USDC

## Links

- Website: https://blockrun.ai
- Live Metrics: https://blockrun.ai/metrics
- Documentation: https://blockrun.ai/docs
- GitHub: https://github.com/BlockRunAI
- X/Twitter: https://x.com/BlockRunAI
- Pricing: https://blockrun.ai/pricing
- Enterprise: https://blockrun.ai/enterprise
- Franklin agent: https://franklin.run

## Optional

- [llms-full.txt](https://blockrun.ai/llms-full.txt): Detailed version with API reference, model pricing, and SDK examples.
~~~

## llms-full

~~~text
# BlockRun — The Payment Rail for AI

> BlockRun is a service marketplace where AI agents discover, route, and pay for APIs using USDC via the x402 protocol. No API keys, no subscriptions, no vendor lock-in. Pay only for what you use.

## What Is BlockRun?

BlockRun is the infrastructure layer that enables AI agents to autonomously pay for services. It provides:

1. **AI Model Gateway** — Access 55+ large language models through a single OpenAI-compatible API endpoint. Models include GPT-5, GPT-4o, Claude Opus 4.7, Claude Sonnet 4.6, Gemini 2.5 Pro, Grok 4.20, Grok Imagine (image+video), DeepSeek Chat, Kimi K2.6, Llama, Mistral, Cohere, Qwen, and more.
2. **ClawRouter** — An open-source smart LLM router that reduces API costs by up to 78% through 7-layer prompt compression, intelligent model routing (routes to the cheapest capable model), and response caching (~200ms latency savings).
3. **Data Marketplace** — Real-time data APIs (prediction markets, neural web search) that AI agents can purchase per-request.
4. **x402 Protocol** — HTTP-native payment standard where AI agents pay with USDC on Base or Solana. Non-custodial — private keys never leave the agent's machine.

## Who Uses BlockRun?

- **AI agent builders** who need their agents to autonomously access multiple AI providers without managing API keys
- **Startups** that want one payment rail for all AI providers instead of managing a dozen API keys and billing accounts
- **Enterprises** that need budget controls, team management, and usage analytics for their AI spending
- **Claude Code users** via the BlockRun MCP server and Claude Code plugin

Trusted by Circle, Coinbase, Solana, Ampersand, T54, and Pin.AI.

## API Reference

Base URL: `https://blockrun.ai`
Solana endpoint: `https://sol.blockrun.ai`
XRPL endpoint: `https://xrpl.blockrun.ai`
Testnet: `https://testnet.blockrun.ai`

## Public Traction

Live at https://blockrun.ai/metrics (refreshed hourly, on-chain verifiable):
- 6,000,000+ API calls served since Feb 2026
- 1,431+ unique paying wallets
- $31,000+ USDC settled on-chain (Base treasury: 0xe9030014F5DAe217d0A152f02A043567b16c1aBf)

### Chat Completions (OpenAI-compatible)

```
POST /v1/chat/completions
```

Request body:
```json
{
  "model": "openai/gpt-4o",
  "messages": [
    {"role": "user", "content": "Hello"}
  ],
  "max_tokens": 1024
}
```

### Image Generation

```
POST /v1/images/generations
POST /v1/images/image2image
```

### Video Generation

```
POST /v1/videos/generations
```

### List Available Models

```
GET /v1/models
```

### Web Search (Exa-powered)

```
POST /api/v1/exa/search        $0.01     Neural/keyword search. Optional category filter: linkedin profile, company, research paper, news, pdf, github, tweet, financial report.
POST /api/v1/exa/find-similar  $0.01     Find semantically similar pages to a given URL.
POST /api/v1/exa/contents      $0.002/URL Extract full text, highlights, and summaries from specific URLs.
POST /api/v1/exa/answer        $0.01     AI-generated answer grounded in live web search results.
```

### Sandbox Compute (Modal)

```
POST /api/v1/modal/sandbox/create     $0.01    Create isolated container (any Docker image, optional GPU: T4–H100).
POST /api/v1/modal/sandbox/exec       $0.001   Execute command in sandbox, returns stdout/stderr/exit code.
POST /api/v1/modal/sandbox/status     $0.001   Check sandbox status (running/terminated).
POST /api/v1/modal/sandbox/terminate  $0.001   Terminate sandbox and release resources.
```

## x402 Payment Flow

1. AI agent sends an API request to BlockRun
2. BlockRun returns HTTP 402 Payment Required with the price in the `x-payment-required` header
3. Agent signs a USDC payment locally (private key never leaves the machine)
4. Agent retries the request with `x-payment` header containing the signed payment
5. BlockRun verifies payment and returns the API response
6. Settlement is non-custodial and instant on Base or Solana

## Available Models and Pricing

All prices are per 1 million tokens. BlockRun charges provider cost + 30% margin.

### Chat Models
| Model | Provider | Input $/M tokens | Output $/M tokens |
|-------|----------|-------------------|---------------------|
| gpt-5.2 | OpenAI | $1.75 | $14.00 |
| gpt-4o | OpenAI | $2.50 | $10.00 |
| gpt-4o-mini | OpenAI | $0.15 | $0.60 |
| claude-opus-4 | Anthropic | $15.00 | $75.00 |
| claude-sonnet-4 | Anthropic | $3.00 | $15.00 |
| gemini-2.5-pro | Google | $1.25 | $10.00 |
| gemini-2.5-flash | Google | $0.15 | $0.60 |
| grok-3 | xAI | $3.00 | $15.00 |
| grok-3-mini | xAI | $0.30 | $0.50 |
| deepseek-chat | DeepSeek | $0.28 | $0.42 |
| kimi-k2.6 | Moonshot | $0.95 | $4.00 |
| kimi-k2.5 | Moonshot | $0.60 | $3.00 |

### Image Models
| Model | Provider | Price |
|-------|----------|-------|
| dall-e-3 | OpenAI | $0.04-0.08/image |
| gpt-image-1 | OpenAI | $0.02-0.04/image |
| gpt-image-2 | OpenAI | $0.06-0.12/image (ChatGPT Images 2.0 — reasoning + multilingual text) |
| nano-banana | Google | $0.05/image |
| nano-banana-pro | Google | $0.10-0.15/image |
| grok-imagine-image | xAI | $0.02/image |
| grok-imagine-image-pro | xAI | $0.07/image |

### Video Models
| Model | Provider | Price |
|-------|----------|-------|
| xai/grok-imagine-video | xAI | $0.05/sec (default 8s) |
| bytedance/seedance-1.5-pro | ByteDance | $0.03/sec (default 5s, budget tier) |
| bytedance/seedance-2.0-fast | ByteDance | $0.15/sec (default 5s, fast) |
| bytedance/seedance-2.0 | ByteDance | $0.30/sec (default 5s, premium quality) |

## SDKs

### Python
```bash
pip install blockrun-llm
```
```python
from blockrun_llm import LLMClient
client = LLMClient()
response = client.chat("openai/gpt-4o", "Hello!")
```

### TypeScript / Node.js
```bash
npm install @blockrun/llm
```
```typescript
import { LLMClient } from "@blockrun/llm";
const client = new LLMClient();
const response = await client.chat("openai/gpt-4o", "Hello!");
```

### Go
```bash
go get github.com/blockrunai/blockrun-llm-go
```

### MCP Server (for Claude Code / Cursor / ChatGPT Desktop)
```bash
claude mcp add blockrun --transport http https://mcp.blockrun.ai/mcp
```

## ClawRouter — Smart LLM Router

ClawRouter is an open-source (MIT licensed) smart router for LLM API calls. It sits between your AI agent and LLM providers, automatically optimizing for cost and performance.

### Features
- **Smart Routing** — Routes requests to the cheapest model capable of handling the task
- **7-Layer Compression** — Reduces token usage by 15-40% without quality loss
- **Response Caching** — ~200ms latency savings on repeated/similar queries
- **Native OpenClaw Support** — Sessions, plugins, memory

### Installation
```bash
# Via GitHub
git clone https://github.com/BlockRunAI/ClawRouter.git
cd ClawRouter && pip install -e .
```

GitHub: https://github.com/BlockRunAI/ClawRouter

## Supported Chains

| Chain | Endpoint | Currency | Status |
|-------|----------|----------|--------|
| Base Mainnet | blockrun.ai | USDC | Production |
| Solana Mainnet | sol.blockrun.ai | USDC | Production |
| Base Sepolia | Testnet | Test USDC | Testing |
| XRPL | Coming soon | — | Planned |

## Enterprise Features

- Budget controls per agent, per project, or organization-wide
- Team management and role-based access
- Real-time usage analytics and cost tracking
- Dedicated account manager and SLA guarantees
- Contact: https://blockrun.ai/enterprise

## Competitive Advantages vs Alternatives

- **vs Direct API keys**: No key management for 12+ providers. One funding source, all providers accessible. Automatic fallback across providers.
- **vs OpenRouter**: Native crypto payments, no custodial accounts needed. x402 protocol is an open standard.
- **vs Building your own**: No billing integration needed. Pay-per-use with natural budget limits. No rate limit juggling.

## Links

- Website: https://blockrun.ai
- Documentation: https://blockrun.ai/docs
- GitHub Organization: https://github.com/BlockRunAI
- ClawRouter: https://github.com/BlockRunAI/ClawRouter
- Python SDK: https://github.com/blockrunai/blockrun-llm
- TypeScript SDK: https://github.com/blockrunai/blockrun-llm-ts
- X/Twitter: https://x.com/BlockRunAI
- Blog: https://blockrun.ai/signal
- Pricing: https://blockrun.ai/pricing
- Enterprise: https://blockrun.ai/enterprise
- Get Started: https://blockrun.ai/get-started

## Awards

- OpenClaw Hackathon Winner (Circle / Coinbase)
~~~