--- name: dexpaprika-api description: "Query on-chain DEX data and stream real-time crypto prices using DexPaprika -- token prices, liquidity pools, OHLCV history, swap transactions, advanced pool filtering, and live price streaming via SSE across 33+ blockchains. Use this skill whenever the user wants to fetch crypto token prices, look up pool or DEX data, get historical candlestick data, find new pools, filter pools by volume/transactions/age, stream live prices, build real-time dashboards, or build anything that needs on-chain DEX data. Also use when the user mentions DexPaprika, dexpaprika, streaming crypto prices, or SSE price feeds. REST docs: https://docs.dexpaprika.com -- Streaming docs: https://docs.dexpaprika.com/streaming/introduction" --- # DexPaprika API Free API for on-chain DEX data and real-time price streaming. 33+ blockchains, 25M+ tokens, 27M+ pools. No API key, no authentication. | Service | Base URL | Purpose | |---|---|---| | REST API | `https://api.dexpaprika.com` | Token data, pools, OHLCV, transactions, search | | Streaming API | `https://streaming.dexpaprika.com` | Real-time price updates via SSE (~1s intervals). [Full docs](https://docs.dexpaprika.com/streaming/introduction) | | CLI | `curl -sSL .../install.sh \| sh` | Terminal tool wrapping the full API. Install: `curl -sSL https://raw.githubusercontent.com/coinpaprika/dexpaprika-cli/main/install.sh \| sh` | All examples use curl, but any HTTP client works. The CLI (`dexpaprika-cli`) wraps every endpoint into simple commands with `--output json --raw` for scripting. REST responses are JSON. Streaming responses are Server-Sent Events. --- ## Core concepts **Network IDs** are lowercase chain identifiers: `ethereum`, `solana`, `bsc`, `arbitrum`, `base`, `polygon`, `optimism`, `avalanche`, etc. Get the full list from `GET /networks`. **Token addresses** are the on-chain contract addresses (e.g., `0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2` for WETH on Ethereum, `So11111111111111111111111111111111111111112` for SOL on Solana). **Pool addresses** are the on-chain liquidity pool contract addresses. Find them via token pools or network pools endpoints. If you don't know the network or address for a token, use search first. --- ## Endpoints ### Search (start here when you don't have addresses) ``` GET /search?query={query} ``` Search tokens, pools, and DEXes by name, symbol, or address. Case-insensitive. Use this to resolve "what's the ETH price" into the actual network + address you need. **Example:** Find Jupiter token ```bash curl "https://api.dexpaprika.com/search?query=jupiter" ``` --- ### Token price and details ``` GET /networks/{network}/tokens/{token_address} ``` Returns name, symbol, chain, decimals, USD price, fully diluted valuation, liquidity, and volume/transaction stats at multiple time windows (24h, 6h, 1h, 30m, 15m, 5m). **The price is at** `response.summary.price_usd` **Example:** Get SOL price ```bash curl "https://api.dexpaprika.com/networks/solana/tokens/So11111111111111111111111111111111111111112" ``` Extract just the price: ```bash curl -s "https://api.dexpaprika.com/networks/solana/tokens/So11111111111111111111111111111111111111112" | jq '.summary.price_usd' ``` --- ### Batch token prices ``` GET /networks/{network}/multi/prices?tokens={addr1},{addr2},{addr3} ``` Fetch USD prices for multiple tokens in one request. Comma-separated addresses, max 10 per request. Unknown or unpriced tokens are silently omitted from the response. **Example:** WETH + USDC on Ethereum ```bash curl "https://api.dexpaprika.com/networks/ethereum/multi/prices?tokens=0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2,0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48" ``` Response is an array of `{id, chain, price_usd}` objects. Order is not guaranteed. --- ### Top pools on a network ``` GET /networks/{network}/pools?page={1}&limit={10}&order_by={volume_usd}&sort={desc} ``` List top liquidity pools. Pages are 1-indexed, max 100 per page. Order by: `volume_usd`, `price_usd`, `transactions`, `last_price_change_usd_24h`, `created_at`. **Example:** Top 5 Ethereum pools by volume ```bash curl "https://api.dexpaprika.com/networks/ethereum/pools?limit=5&order_by=volume_usd&sort=desc" ``` --- ### Advanced pool filtering (new) ``` GET /networks/{network}/pools/filter ``` Filter pools with range queries on volume, transactions, and creation date. This is the endpoint to use for building pool screeners, finding high-volume pools, or discovering recently created pools that meet specific criteria. **Parameters:** | Parameter | Type | Description | |---|---|---| | `page` | integer | Page number, **1-indexed** (default: 1) | | `limit` | integer | Items per page, 1-100 (default: 50) | | `volume_24h_min` | number | Min 24h volume in USD | | `volume_24h_max` | number | Max 24h volume in USD | | `txns_24h_min` | integer | Min transactions in last 24h | | `created_after` | integer | UNIX timestamp -- only pools created after this | | `created_before` | integer | UNIX timestamp -- only pools created before this | | `sort_by` | string | `volume_24h` (default), `txns_24h`, `created_at` | | `sort_dir` | string | `asc` or `desc` (default: `desc`) | Note: `volume_7d_min`, `volume_30d_min`, `liquidity_usd_min`, `liquidity_usd_max` exist in the spec but are not functional yet -- they return empty results. All filters combine with AND logic. The response includes `page_info` with `total_items` and `total_pages`. **Example:** High-volume Ethereum pools (>$100k daily volume) ```bash curl "https://api.dexpaprika.com/networks/ethereum/pools/filter?volume_24h_min=100000&sort_by=volume_24h&sort_dir=desc" ``` **Example:** Recently created Solana pools with activity ```bash curl "https://api.dexpaprika.com/networks/solana/pools/filter?created_after=1709251200&txns_24h_min=50&sort_by=created_at&sort_dir=desc" ``` --- ### Pool details ``` GET /networks/{network}/pools/{pool_address}?inversed={false} ``` Returns liquidity, reserves, pricing, token pair info, and DEX metadata for a specific pool. Set `inversed=true` to flip the price ratio (token1/token0 instead of token0/token1). --- ### Pool OHLCV (historical candlesticks) ``` GET /networks/{network}/pools/{pool_address}/ohlcv?start={timestamp}&interval={24h}&limit={30} ``` Historical price candlestick data. `start` is required (ISO 8601 or UNIX timestamp). Optional `end` (max 1 year from start). **Intervals:** `1m`, `5m`, `10m`, `15m`, `30m`, `1h`, `6h`, `12h`, `24h` **Max data points:** 366 per request **Example:** Last 30 days of daily candles for a pool ```bash curl "https://api.dexpaprika.com/networks/ethereum/pools/0x88e6a0c2ddd26feeb64f039a2c41296fcb3f5640/ohlcv?start=2025-01-01&interval=24h&limit=30" ``` --- ### Pool transactions ``` GET /networks/{network}/pools/{pool_address}/transactions?page={1}&limit={20} ``` Recent swaps, liquidity adds, and removes. Reverse chronological order. Pages 1-indexed, max 100 pages. For deep pagination, use `cursor` parameter (transaction ID) instead of page numbers. Each transaction includes: token amounts (`amount_0`, `amount_1`), volumes (`volume_0`, `volume_1`), USD prices (`price_0_usd`, `price_1_usd`), token symbols, sender/recipient, and timestamps. --- ### Pools for a token ``` GET /networks/{network}/tokens/{token_address}/pools?order_by={volume_usd}&sort={desc}&limit={10} ``` Find all pools containing a specific token. Optional: add `address` parameter to filter to pools paired with a second specific token. Add `reorder=true` to make the queried token the primary token in all metrics. --- ### DEXes on a network ``` GET /networks/{network}/dexes ``` List all DEXes on a network with their identifiers. Use the `dex` id to filter pools: ``` GET /networks/{network}/dexes/{dex}/pools ``` --- ### Networks ``` GET /networks ``` Returns all supported blockchain networks with their IDs. Use these IDs in all other endpoints. --- ### Platform stats ``` GET /stats ``` High-level counts: total networks, DEXes, pools, and tokens. Useful for health checks. --- ## Streaming API -- Real-time prices via SSE Stream live token prices with ~1 second update intervals. Uses Server-Sent Events (SSE) -- works with any HTTP client that supports streaming. For full streaming docs, guides, and code examples see: https://docs.dexpaprika.com/streaming/introduction **Base URL:** `https://streaming.dexpaprika.com` (no landing page -- only the `/stream` paths below work) ### Stream a single token (GET) ```bash curl -N "https://streaming.dexpaprika.com/stream?method=t_p&chain=ethereum&address=0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2" ``` ### Stream multiple tokens (POST) -- recommended for 2+ tokens Send a JSON array of assets. Single connection, up to 2,000 tokens. ```bash curl -N -X POST "https://streaming.dexpaprika.com/stream" \ -H "Accept: text/event-stream" \ -H "Content-Type: application/json" \ -d '[ {"chain": "solana", "address": "So11111111111111111111111111111111111111112", "method": "t_p"}, {"chain": "ethereum", "address": "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2", "method": "t_p"} ]' ``` Each asset object requires `chain` (network ID), `address` (token contract), and `method` (always `t_p` for token price). ### SSE event format ``` data: {"a":"0xc02a...","c":"ethereum","p":"2739.79","t":1769778188,"t_p":1769778187} event: t_p ``` | Field | Meaning | |---|---| | `a` | Token address | | `c` | Chain ID | | `p` | Price in USD (string for precision -- parse as decimal) | | `t` | Server send timestamp (UNIX seconds) | | `t_p` | Price event timestamp (UNIX seconds) | Use `now() - t` for network latency, `now() - t_p` for total price data latency. ### Python streaming example ```python import requests, json assets = [ {"chain": "ethereum", "address": "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2", "method": "t_p"}, {"chain": "solana", "address": "So11111111111111111111111111111111111111112", "method": "t_p"} ] r = requests.post("https://streaming.dexpaprika.com/stream", headers={"Accept": "text/event-stream", "Content-Type": "application/json"}, json=assets, stream=True) for line in r.iter_lines(): if line and line.startswith(b'data:'): data = json.loads(line[5:]) print(f"{data['c']} {data['a']}: ${data['p']}") ``` ### Streaming constraints - **Max 2,000 assets** per POST request - **All assets must be valid** -- one invalid asset cancels the entire stream with HTTP 400 - **Global stream limit:** 10,000 concurrent streams per server - Validate assets via REST `/search` before streaming - Use multiple smaller requests (100-500 each) rather than one massive request for better load distribution - Reconnect with exponential backoff on disconnect ### Streaming errors | Status | Meaning | |---|---| | 200 | Connected, streaming | | 400 | Bad params, unsupported chain, asset not found, or one invalid asset in batch | | 429 | Global stream limit exceeded -- retry with backoff | Errors during an active stream arrive as SSE events: `event: error` + `data: {"message": "..."}`. Handle both HTTP errors (before stream starts) and SSE errors (during streaming). --- ## Constraints and limits ### REST API - **Rate limit:** 10,000 requests per day - **Batch prices:** max 10 tokens per request - **Pagination:** max 100 items per page - **OHLCV:** max 366 data points per request, max 1 year range - **Transactions:** max 100 pages of pagination - **Pagination:** all endpoints are 1-indexed (page=0 is silently treated as page=1) ### Streaming API - **Max assets per request:** 2,000 - **Global concurrent streams:** 10,000 per server - **All assets must be valid** or entire stream is cancelled --- ## Error handling | Status | Meaning | What to do | |---|---|---| | 200 | Success | Parse JSON response | | 400 | Bad request (invalid params, too many tokens, bad sort field) | Check parameter values and constraints above | | 404 | Network, token, or pool not found | Verify the network ID and address; use /search to find correct values | | 410 | Endpoint deprecated (old /pools) | Use `/networks/{network}/pools` instead | | 429 | Rate limit exceeded | Back off and retry; consider caching responses | | 500 | Server error | Retry with backoff | When a batch price request contains only invalid tokens, you get HTTP 200 with an empty array -- not an error. --- ## Common workflows ### "What's the price of X?" 1. `GET /search?query=X` to find the network and token address 2. `GET /networks/{network}/tokens/{address}` to get price at `.summary.price_usd` ### "Show me the top pools on Ethereum" 1. `GET /networks/ethereum/pools?limit=10&order_by=volume_usd&sort=desc` ### "Find new pools with high volume" 1. `GET /networks/{network}/pools/filter?created_after={unix_timestamp}&volume_24h_min=50000&sort_by=created_at&sort_dir=desc` ### "Get historical price data for a token" 1. Find the token's pools via `GET /networks/{network}/tokens/{address}/pools?order_by=volume_usd&sort=desc&limit=1` (the highest-volume pool is the best source) 2. `GET /networks/{network}/pools/{pool_address}/ohlcv?start={date}&interval=24h&limit=30` ### "Compare prices of multiple tokens" 1. `GET /networks/{network}/multi/prices?tokens={addr1},{addr2},{addr3}` ### "Stream live price updates for a token" 1. `GET https://streaming.dexpaprika.com/stream?method=t_p&chain={network}&address={token_address}` ### "Build a real-time dashboard tracking multiple tokens" 1. Validate tokens exist via REST: `GET /search?query={name}` or `GET /networks/{network}/tokens/{address}` 2. `POST https://streaming.dexpaprika.com/stream` with JSON array of `{chain, address, method: "t_p"}` objects 3. Parse SSE events, read price from `p` field (string -- parse as decimal for precision) ### "Monitor a token's price with alerts" 1. Stream the token via GET or POST to `streaming.dexpaprika.com` 2. Compare each incoming `p` value against your threshold 3. Reconnect with exponential backoff on disconnect --- ## What this skill does NOT cover - **CoinPaprika centralized exchange data** -- that's a different API (`api.coinpaprika.com`) - **Trading or swapping** -- DexPaprika is read-only; it does not execute trades --- ## Full documentation - [REST API reference](https://docs.dexpaprika.com/api-reference/introduction) - [Streaming API docs](https://docs.dexpaprika.com/streaming/introduction) - [Tutorials](https://docs.dexpaprika.com/tutorials/tutorial_intro)