DEX & On-chain Crypto API – Liquidity, Swaps, Tokens

Looking for the full API spec? Jump to the Streaming Reference tab for every endpoint, parameter, response schema, and a live API playground.

🎬 See Streaming API in Action

Live Demo: Watch our interactive dashboard stream real-time prices for 6 cryptocurrencies across Ethereum, Solana, and BSC. See connection status, latency metrics, and live updates in action. Open Live Dashboard →

Overview

DexPaprika’s Streaming API delivers two real-time feeds via Server-Sent Events (SSE): live token prices and live pool reserve updates. Build responsive applications with sub-second data, no polling, and no API key required.

No Authentication

Public endpoints with no API keys needed. Start streaming immediately.

Real-Time Updates

Receive price updates approximately every second; reserve updates land block-by-block as swaps and liquidity changes settle on-chain.

SSE Protocol

Standard Server-Sent Events for easy integration with any modern platform.

Multi-Chain Support

Stream tokens and pools from Ethereum, Solana, BSC, Arbitrum, Base, and more networks.

Two feeds, one transport

Token Prices (/sse/prices)

USD price updates per token, pushed roughly every second per asset. Use this for tickers, portfolios, price-alert systems, and dashboards.

Pool Reserves (/sse/reserves)

Block-level pool reserve deltas, USD-denominated, for any DEX pool or any token. Use this for liquidity monitoring, TVL dashboards, slippage estimation, and MEV/arbitrage detection. Learn more →

Why Use Streaming?

Streaming vs Traditional Polling

SSE Streaming (Recommended)
Polling (Not Recommended)

// Efficient: Server pushes updates only when prices change
const url = 'https://streaming.dexpaprika.com/sse/prices?method=token_price&chain=ethereum&address=0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2';
const eventSource = new EventSource(url);

eventSource.addEventListener('token_price', (event) => {
  const data = JSON.parse(event.data);
  updatePrice(data.price);
});

Benefits:

Single persistent connection
Updates pushed immediately when available
Minimal bandwidth usage
No rate limiting concerns

// Inefficient: Constant requests even when prices don't change
setInterval(async () => {
  const response = await fetch('https://api.dexpaprika.com/networks/ethereum/tokens/0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2');
  const data = await response.json();
  updatePrice(data.summary.price_usd);
}, 1000); // 86,400 requests per day per asset!

Drawbacks:

High server load from repeated requests
Wasted bandwidth when prices don’t change
Potential rate limiting issues
Higher latency for updates

Use Cases

What You Can Build

Trading Dashboards

Display live prices, volume, and market metrics with sub-second latency. See live example →

Portfolio Trackers

Show real-time portfolio values and P&L as prices fluctuate.

Price Alert Systems

Trigger instant notifications when prices hit target levels.

DEX Aggregators

Compare prices across chains for arbitrage opportunities.

Market Tickers

Create live price tickers and widgets for websites.

Analytics Platforms

Stream data into time-series databases for real-time analytics.

Available Endpoints

Each feed has a single-asset GET form and a multi-asset POST form:

Token price streams (`/sse/prices`)

GET /sse/prices

Stream one token’s price per connection. Pass method, chain, and address as query params.

POST /sse/prices

Stream multiple tokens (up to 25 per connection) by posting a JSON array of {chain, address, method} entries.

Pool reserve streams (`/sse/reserves`)

GET /sse/reserves

Stream reserve updates for a single pool (method=pool_reserves) or a single token across every pool it sits in (method=token_reserves).

POST /sse/reserves

Subscribe to up to 25 pools or tokens in one connection. Mix pool_reserves and token_reserves entries freely.

The legacy /stream path is still accepted but deprecated. It now emits a warning event on connect ("stream is deprecated, move to /sse/prices instead") and will be removed in a future release. The legacy /reserves/stream path has already been retired; use /sse/reserves.

Quick Comparison

Feature	GET (Single)	POST (Multi)
Subscriptions per request	1	Up to 25
Best for	Individual asset/pool tracking	Portfolios, dashboards, multi-pool monitoring
Setup complexity	Minimal	Moderate
Load distribution	Per connection	Automatic balancing

For workloads larger than 25 subscriptions, open multiple parallel POST streams.

Quick Start

1. Choose Your Method

Single Asset (Simple)
Multiple Assets (Advanced)

Stream Ethereum WETH price:

curl -N "https://streaming.dexpaprika.com/sse/prices?method=token_price&chain=ethereum&address=0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2"

Stream SOL and USDC prices:

curl -X POST "https://streaming.dexpaprika.com/sse/prices" \
  -H "Accept: text/event-stream" \
  -H "Content-Type: application/json" \
  -d '[
    {"chain": "solana", "address": "So11111111111111111111111111111111111111112", "method": "token_price"},
    {"chain": "ethereum", "address": "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48", "method": "token_price"}
  ]'

2. Parse the Response

Each price update arrives as a JSON event. The default method token_price returns full field names:

{
  "address": "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2",
  "chain": "ethereum",
  "price": "2257.973351845954",
  "timestamp": 1778846475,
  "timestamp_price": 1778846474,
  "token_price": 1778846474
}

The legacy t_p method emits a compact shape with single-letter keys (a, c, p, t, t_p). It is deprecated and kept only for backward compatibility.

3. Handle in Your Application

const eventSource = new EventSource(url);

eventSource.addEventListener('token_price', (event) => {
  const price = JSON.parse(event.data);
  console.log(`${price.chain} ${price.address}: $${price.price}`);
});

// Optional: surface deprecation notices the server may push
eventSource.addEventListener('warning', (event) => {
  const { message } = JSON.parse(event.data);
  console.warn('[stream warning]', message);
});

eventSource.onerror = () => {
  // Reconnect logic
  eventSource.close();
  setTimeout(connectStream, 1000);
};

Architecture Overview

Key Features

Automatic Load Balancing: Requests distributed across multiple servers
Persistent Connections: Single connection maintained for entire session
Efficient Updates: Only sends data when prices actually change
Global Infrastructure: Low-latency servers in multiple regions

Limits & Quotas

Service limits enforced by the streaming gateway:

Limit	Value	Notes
Concurrent SSE streams per IP	10	Exceeding returns `429 Too Many Requests` with body `{"message": "ip stream limit exceeded"}`
Subscriptions per POST connection	25	`POST /sse/prices` rejects with `{"message":"too many assets, max 25 allowed"}`. `POST /sse/reserves` rejects with `{"message":"too many subscriptions"}`
Ping interval	15 seconds	A `ping` event is pushed periodically to keep the connection open

Event types you may receive

Event	When	Payload
`token_price`	New price observation for a subscribed token	`{address, chain, price, timestamp, timestamp_price}`
`reserve_update`	Pool reserves changed on the latest indexed block	`{chain, pool_id, block, previous_block, tokens[], total_reserve_usd, total_delta_usd}`
`ping`	Every ~15s while idle	`{"time": <unix>}`
`warning`	Deprecation notices or other non-fatal signals	`{"message": "..."}`
`error`	Stream-terminating error (e.g. invalid asset)	`{"message": "..."}`
`t_p`	Deprecated. Legacy compact price shape (`{a, c, p, t, t_p}`). Use `token_price` instead.

Parsers should skip events whose event: field is not in the allow-list they care about. The set may grow over time (e.g. new warning event was added in May 2026), so an unrecognised event must never crash your handler.

Best Practices

Connection Management

Implement automatic reconnection with exponential backoff
Handle both network errors and SSE error events
Monitor connection health with heartbeat timeouts

Error Handling

Validate all assets before streaming (invalid assets cancel entire stream)
Parse both HTTP errors and SSE error events
Log errors for debugging but don’t expose sensitive data

Performance Optimization

Use POST method for multiple assets (better than multiple GETs)
Split large requests across multiple smaller streams
Parse price strings carefully to maintain precision

Production Deployment

Implement proper logging and monitoring
Set up alerts for connection drops
Use connection pooling for multiple streams
Consider WebSocket bridges for incompatible clients

Supported Networks

Stream tokens from multiple blockchain networks. Use the Networks API to get the full list of supported networks:

curl https://api.dexpaprika.com/networks

Popular networks include:

Ethereum (ethereum)
Solana (solana)
Binance Smart Chain (bsc)
Arbitrum (arbitrum)
Polygon (polygon)
Base (base)
Avalanche (avalanche)

The chain parameter in streaming requests must use the exact id value from the Networks endpoint.

Finding Token Addresses

Before streaming prices, you need the correct token address for your chosen network. Use these REST API endpoints:

Search for Tokens

Use the Search API to find tokens by name or symbol:

curl "https://api.dexpaprika.com/search?query=USDC"

Get Token Details

Find all pools for a specific token using the Token Pools API:

curl "https://api.dexpaprika.com/networks/ethereum/tokens/0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48/pools"

Validate Before Streaming

Use the Token Prices API to verify your token exists before streaming:

curl "https://api.dexpaprika.com/networks/ethereum/multi/prices?tokens=0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48"

Always verify the token address matches the network you’re streaming from. The same token may have different addresses on different chains.

The streaming API will return a 400 Asset not found error if the token doesn’t exist on the specified network. Validate tokens using the REST API first to avoid stream failures.

Next Steps

Reserves Streaming

The deep dive on /sse/reserves: what gets pushed every block, the two subscription methods, annotated wire example, use cases for LPs, MEV builders, and analytics teams.

Quick Start Tutorial

Build your first streaming application in 5 minutes. Covers both prices and reserves.

🚀 Live Dashboard Demo

Interactive streaming demo. Pick a chain, pick tokens, watch the SSE events flow in real time.

React Integration

Build streaming components for React and Next.js applications.

Get Support

Discord Community

Join our Discord for real-time support and discussions.

Email Support

Contact our team for technical assistance.

Documentation Index

🎬 See Streaming API in Action

​Overview

No Authentication

Real-Time Updates

SSE Protocol

Multi-Chain Support

​Two feeds, one transport

Token Prices (/sse/prices)

Pool Reserves (/sse/reserves)

​Why Use Streaming?

​Streaming vs Traditional Polling

​Use Cases

​What You Can Build

Trading Dashboards

Portfolio Trackers

Price Alert Systems

DEX Aggregators

Market Tickers

Analytics Platforms

​Available Endpoints

​Token price streams (/sse/prices)

GET /sse/prices

POST /sse/prices

​Pool reserve streams (/sse/reserves)

GET /sse/reserves

POST /sse/reserves

​Quick Comparison

​Quick Start

​1. Choose Your Method

​2. Parse the Response

​3. Handle in Your Application

​Architecture Overview

​Key Features

​Limits & Quotas

​Event types you may receive

​Best Practices

​Supported Networks

​Finding Token Addresses

​Search for Tokens

​Get Token Details

​Validate Before Streaming

​Next Steps

Reserves Streaming

Quick Start Tutorial

🚀 Live Dashboard Demo

React Integration

​Get Support

Discord Community

Email Support

Overview

Two feeds, one transport

Why Use Streaming?

Streaming vs Traditional Polling

Use Cases

What You Can Build

Available Endpoints

Token price streams (`/sse/prices`)

Pool reserve streams (`/sse/reserves`)

Quick Comparison

Quick Start

1. Choose Your Method

2. Parse the Response

3. Handle in Your Application

Architecture Overview

Key Features

Limits & Quotas

Event types you may receive

Best Practices

Supported Networks

Finding Token Addresses

Search for Tokens

Get Token Details

Validate Before Streaming

Next Steps

Get Support