> ## Documentation Index
> Fetch the complete documentation index at: https://docs.dexpaprika.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Pro API: authenticated access on api-pro.dexpaprika.com

> api-pro.dexpaprika.com serves paid plans only and needs your API key in the Authorization header. What to send, what each error means, and how to move an existing integration across.

`api-pro.dexpaprika.com` serves paid plans only. Every request to it needs your API key in the `Authorization` header, sent as the entire header value with no scheme word in front of it.

If you are keyless or on a free key, this is not your host. Build against `api.dexpaprika.com`, where the same endpoints, paths and parameters answer with the same data. Get or copy your key in [console.dexpaprika.com](https://console.dexpaprika.com), compare plans on [pricing](https://dexpaprika.com/api/pricing), and if you already have a working free-tier integration, [upgrading to Pro](/api-pro/upgrading) is the whole list of changes it needs.

```bash A request that works theme={null}
curl "https://api-pro.dexpaprika.com/networks" \
  -H "Authorization: api_YOUR_KEY"
```

## If your request just failed

| What you sent                             | What comes back                                                                           |
| ----------------------------------------- | ----------------------------------------------------------------------------------------- |
| No `Authorization` header, on `/`         | `401` and JSON: `{"message": "missing or invalid api key"}`                               |
| No `Authorization` header, on a data path | `403` and an HTML block page from the edge, with no JSON body                             |
| A key we do not recognise                 | `401` and JSON: `{"message": "api key verification has failed"}`                          |
| A free key                                | `403` and JSON carrying `"error": "wrong_host"`, naming `api.dexpaprika.com` as your host |

The HTML body is the one that surprises people. This host sits behind an edge rule that can reject a request before it reaches the API, and that rule answers with an HTML page rather than the JSON everything else here returns. Treat an HTML body as a prompt to check the header and the base URL first, before you regenerate anything. Every status code and body is listed on [error handling](/knowledge-base/error-handling).

## What Pro changes

Both hosts serve the same data: the same endpoints, the same 36 chains, the same history. What changes is freshness, headroom and support. Free-tier responses can be up to 60 seconds behind; Pro is real time. Pro also raises the monthly credit allowance and the per-minute rate, carries a 99.5% SLA, and includes priority support. Current numbers for every tier are on [rate limits](/knowledge-base/rate-limits) and [pricing](https://dexpaprika.com/api/pricing).

Enterprise is this same host and this same API, with the limits set per contract.

***

## Getting started

### 1. Get your API key

Pro is self-serve. You do not need to talk to anyone to start.

<Steps>
  <Step title="Create your account">
    Sign up at [console.dexpaprika.com](https://console.dexpaprika.com). No card
    is required to create the account.
  </Step>

  <Step title="Subscribe to Pro">
    Pick Pro on the [pricing page](https://dexpaprika.com/api/pricing) at
    $99/month, or $1,032 billed annually. Enterprise is the same API with limits
    agreed per contract; that one does start with a conversation.
  </Step>

  <Step title="Copy your key">
    Your key is under **Keys** in the console. Each account has a single API key,
    so this is the one you use everywhere.
  </Step>
</Steps>

<CardGroup cols={2}>
  <Card title="Open the console" icon="key" href="https://console.dexpaprika.com">
    Create an account, manage your subscription, and read your usage
  </Card>

  <Card title="Customer portal" icon="key" href="https://console.dexpaprika.com">
    Create your API key and track credit usage
  </Card>
</CardGroup>

Enterprise is the one that goes through us. [Email the team](mailto:support@coinpaprika.com) for custom limits, unmetered streaming and a 99.95% SLA.

<Note>
  Building on the free tier first is the right move: `api.dexpaprika.com` needs
  no key at all and serves the same data. Come here when you hit the ceiling.
</Note>

### 2. Authentication

All Pro API requests require authentication via the `Authorization` header:

<CodeGroup>
  ```bash cURL theme={null}
  curl "https://api-pro.dexpaprika.com/networks/ethereum/pools/search" \
      -H "Authorization: api_YOUR_API_KEY_HERE"
  ```

  ```python Python theme={null}
  import requests

  headers = {
      "Authorization": "api_YOUR_API_KEY_HERE"
  }

  response = requests.get(
      "https://api-pro.dexpaprika.com/networks/ethereum/pools/search",
      headers=headers
  )
  print(response.json())
  ```

  ```javascript JavaScript theme={null}
  const headers = {
    'Authorization': 'api_YOUR_API_KEY_HERE'
  };

  fetch('https://api-pro.dexpaprika.com/networks/ethereum/pools/search', {
    headers: headers
  })
    .then(response => response.json())
    .then(data => console.log(data));
  ```

  ```go Go theme={null}
  package main

  import (
      "fmt"
      "io"
      "net/http"
  )

  func main() {
      req, _ := http.NewRequest("GET", "https://api-pro.dexpaprika.com/networks/ethereum/pools/search", nil)
      req.Header.Set("Authorization", "api_YOUR_API_KEY_HERE")

      client := &http.Client{}
      resp, _ := client.Do(req)
      defer resp.Body.Close()

      body, _ := io.ReadAll(resp.Body)
      fmt.Println(string(body))
  }
  ```
</CodeGroup>

### 3. API key format

Your API key will follow this format:

```
api_your_personal_api_key
```

Your key already starts with `api_`. Send it exactly as the console shows it, as the entire value of the `Authorization` header, with nothing added in front.

<Warning>
  Send the key as the entire `Authorization` header value, nothing before it and nothing
  after it. If your HTTP client only offers a token field that prepends a scheme word, do
  not use it; set a raw header instead. On `api-pro.dexpaprika.com` a request the edge does
  not recognise is answered with a `403` HTML page rather than a JSON error body, so do not
  assume every failure parses as JSON.
</Warning>

***

## Differences from the free API

| Feature                 | Free API                                                                         | Pro API                                                 |
| ----------------------- | -------------------------------------------------------------------------------- | ------------------------------------------------------- |
| **Base URL**            | `https://api.dexpaprika.com`                                                     | `https://api-pro.dexpaprika.com`                        |
| **Authentication**      | None required                                                                    | API key required                                        |
| **Credits**             | 30,000 keyless, 100,000 with a free key, per rolling 30 days                     | 5,000,000 a month included, then \$20 per additional 1M |
| **Requests per minute** | 15 keyless, 30 with a [free key](https://console.dexpaprika.com)                 | 500                                                     |
| **Max data delay**      | up to 60 seconds                                                                 | real time                                               |
| **SLA**                 | best effort                                                                      | 99.5%                                                   |
| **Infrastructure**      | Shared                                                                           | Dedicated                                               |
| **Support**             | Community                                                                        | Priority support                                        |
| **REST endpoints**      | All endpoints                                                                    | All endpoints                                           |
| **SSE streaming**       | 35 public token streams keyless; any token, up to 10 concurrent, with a free key | metered, up to 100 concurrent                           |

Credit detail lives on the [rate limits page](/knowledge-base/rate-limits), and plans on [pricing](https://dexpaprika.com/api/pricing). Every REST endpoint, all history and all 36 chains are available on the free tier as well; what the paid plans change is freshness, allowance, streaming scope and support. **Enterprise is this same API with the limits raised for your workload**, so everything below applies unchanged.

**Dev sits between the two.** For $30 a month you get 500,000 credits per billing month, 120 requests a minute and up to 30 concurrent streams, on this same host and with the same key format as Pro. Data is real time and support is email; the SLA stays best effort rather than the 99.5% Pro carries, and past the included credits Dev bills at the same $20 per additional 1M. Check [pricing](https://dexpaprika.com/api/pricing) for the current numbers.

<Tip>
  All REST endpoints available in the free API are also available in the Pro API. Simply replace the base URL and add authentication.
</Tip>

***

## Quick start example

Let's fetch Solana SOL token data using the Pro API:

<Steps>
  <Step title="Prepare your request">
    Replace `YOUR_API_KEY_HERE` with your actual API key:

    ```bash theme={null}
    curl "https://api-pro.dexpaprika.com/networks/solana/tokens/So11111111111111111111111111111111111111112" \
        -H "Authorization: api_YOUR_API_KEY_HERE"
    ```
  </Step>

  <Step title="Receive the response">
    The same data the free API returns, captured live. The `30m`, `15m`, `5m` and `1m` interval
    objects and the social links are trimmed here for length; the real response carries them:

    ```json Response [expandable] theme={null}
    {
      "id": "So11111111111111111111111111111111111111112",
      "name": "Wrapped SOL",
      "symbol": "SOL",
      "chain": "solana",
      "decimals": 9,
      "total_supply": 9729104.429281628,
      "has_image": true,
      "added_at": "2026-08-10T14:20:16Z",
      "price_stats": {
        "high_24h": 97.72851812469702,
        "low_24h": 92.53839547091638,
        "ath": 2094.381880389729,
        "ath_date": "2025-02-18T22:43:00Z"
      },
      "summary": {
        "chain": "solana",
        "id": "So11111111111111111111111111111111111111112",
        "price_usd": 95.00021242163845,
        "fdv": 924266987.4540582,
        "liquidity_usd": 553757948.2095541,
        "pools": 79958,
        "24h": {
          "volume": 55022471.30115615,
          "volume_usd": 5215005748.220995,
          "sells": 15117657,
          "buys": 8886063,
          "txns": 24126210,
          "buy_usd": 2528611480.8570423,
          "sell_usd": 2686394267.3639526,
          "last_price_usd_change": 1.36503236687871
        },
        "6h": {
          "volume": 15008105.889129847,
          "volume_usd": 1415167906.7786279,
          "sells": 3848462,
          "buys": 2257851,
          "txns": 6135660,
          "buy_usd": 686184008.4416271,
          "sell_usd": 728983898.3370007,
          "last_price_usd_change": 0.8177448219626
        },
        "1h": {
          "volume": 2522513.1508265836,
          "volume_usd": 239070465.79418552,
          "sells": 694311,
          "buys": 363197,
          "txns": 1063751,
          "buy_usd": 115287924.18944858,
          "sell_usd": 123782541.60473694,
          "last_price_usd_change": 0.20697823770267
        }
      },
      "last_updated": "2026-08-24T10:33:47.365548003Z"
    }
    ```
  </Step>
</Steps>

***

## Error handling

### Authentication errors

<AccordionGroup>
  <Accordion title="403 and an HTML page saying you have been blocked">
    The response is not JSON. The body is an HTML page headed **"Sorry, you have been
    blocked"** with a Cloudflare ray ID.

    **What it means:** the request reached this host carrying no `Authorization` header at
    all, so it was stopped at the edge before the API saw it. It is not an IP ban and there
    is no cooldown: the next request with a header is served normally.

    **Solution:** send your key in the `Authorization` header. If you are parsing responses
    as JSON, check the content type first, because this one will not parse.
  </Accordion>

  <Accordion title="401 Unauthorized - no key, or a key we do not recognise">
    **Error response:**

    ```json theme={null}
    {
      "message": "api key verification has failed"
    }
    ```

    The host root answers `{"message": "missing or invalid api key"}` for the same reason.

    **Solution:** the header arrived but its value is not a key we know. Copy the key again
    from [console.dexpaprika.com](https://console.dexpaprika.com). Each account has exactly
    one key and regenerating has no overlap window, so if you regenerated it, every
    integration needs the new value.
  </Accordion>

  <Accordion title="403 Forbidden - the key and the host disagree">
    A key that is valid for one plan sent to the other plan's host returns a structured
    `wrong_host` body naming the host to use.

    **Solution:** match the host to your plan. Keyless traffic and free keys go to
    `api.dexpaprika.com` and `streaming.dexpaprika.com`; paid keys go to
    `api-pro.dexpaprika.com` and `streaming-pro.dexpaprika.com`. Paths, query parameters and
    response shapes are identical, so only the base URL changes. Full detail on
    [403 Forbidden (wrong host)](/knowledge-base/error-handling#403-forbidden-wrong-host),
    and the whole switch is in [upgrading to Pro](/api-pro/upgrading).
  </Accordion>
</AccordionGroup>

### Other errors

All other error codes match the [standard DexPaprika API](/api-reference/introduction):

* `400 Bad Request` - Invalid parameters
* `402 Payment Required` - credit allowance for the billing period exhausted. Retrying does not help. Turn on autoscaling in [console.dexpaprika.com](https://console.dexpaprika.com) to let usage run past the cap at \$20 per additional 1,000,000, up to your spend limit. See [error handling](/knowledge-base/error-handling#402-payment-required)
* `404 Not Found` - Resource not found
* `429 Too Many Requests` - per-minute rate exceeded. Retry after the `Retry-After` header
* `500 Internal Server Error` - Server error

***

## Available endpoints

The Pro API provides access to all DexPaprika endpoints:

<CardGroup cols={2}>
  <Card title="Tokens" icon="coins" href="/api-reference/tokens/get-a-tokens-latest-data-on-a-network">
    Get detailed token information including price, liquidity, and trading volume
  </Card>

  <Card title="Pools" icon="water" href="/api-reference/pools/get-a-pool-on-a-network">
    Access liquidity pool data and trading statistics
  </Card>

  <Card title="Networks" icon="globe" href="/api-reference/networks/get-a-list-of-available-blockchain-networks">
    List all supported blockchain networks
  </Card>

  <Card title="Pool transactions" icon="arrow-right-arrow-left" href="/api-reference/pools/get-transactions-of-a-pool-on-a-network-paging-can-be-used-up-to-100-pages">
    Query swap transactions, adds, and removes
  </Card>

  <Card title="Search" icon="magnifying-glass" href="/api-reference/search/search-for-tokens-pools-and-dexes">
    Search across tokens, pools, and DEXes
  </Card>

  <Card title="Batched prices" icon="layer-group" href="/api-reference/tokens/get-batched-prices-for-multiple-tokens-on-a-network">
    Retrieve multiple token prices in a single request
  </Card>
</CardGroup>

<Note>
  View complete API documentation in the [REST API Reference](/api-reference/introduction) section. All examples use the free API URL - simply replace with `api-pro.dexpaprika.com` and add authentication.
</Note>

***

## Migration guide

Moving an existing free-tier integration across takes two changes: the base URL, and your
key in the `Authorization` header on every request. The full walkthrough, with before and
after code in four languages, what each failure looks like on the wire, and a checklist to
run before you deploy, is on [upgrading to Pro](/api-pro/upgrading).

***

## Best practices

<AccordionGroup>
  <Accordion title="Secure your API key" icon="lock">
    **Never expose your API key in client-side code or public repositories.**

    * Store API keys in environment variables or secure vaults (e.g., AWS Secrets Manager, HashiCorp Vault)
    * Use `.env` files locally and add them to `.gitignore`
    * Rotate keys periodically as part of security best practices
    * Never hardcode keys in your application source code

    ```bash Example .env file theme={null}
    DEXPAPRIKA_PRO_API_KEY=api_your_personal_api_key
    ```
  </Accordion>

  <Accordion title="Monitor your API usage" icon="chart-line">
    **Track your API usage to optimize performance and identify issues early.**

    * Watch credit spend against your allowance in [console.dexpaprika.com](https://console.dexpaprika.com), or call `GET https://api-pro.dexpaprika.com/usage` with your key in the `Authorization` header; `requests_used`, `requests_left` and the period dates come back only for an authenticated call on that host
    * Log all API requests and responses for debugging
    * Set up monitoring dashboards to track request volumes
    * Monitor response times and error rates
    * Alert on unusual patterns or spikes in traffic
    * Review usage patterns to optimize your integration
  </Accordion>

  <Accordion title="Implement robust error handling" icon="triangle-exclamation">
    **Always handle authentication errors gracefully and implement retry logic.**

    * Treat 401 and 403 as configuration faults, not key faults: check the header and the base URL before touching the key
    * Implement exponential backoff for transient failures
    * Don't retry on authentication errors; fix the header or the base URL first
    * Log errors with context for easier troubleshooting
    * Provide meaningful error messages to end users

    ```javascript Example error handling theme={null}
    try {
      const response = await fetch(url, { headers });
      if (response.status === 403) {
        // On api-pro a 403 means the request was rejected before the API saw it, or the
        // key belongs to the other host. Check that the Authorization header is present
        // and holds the key alone, and that the base URL is api-pro.dexpaprika.com.
        // Do not regenerate the key: there is one key per account, and regenerating it
        // breaks every other integration at once.
        return;
      }
      if (response.status === 401) {
        // The header is missing, or the key was not recognised. Fix the header, do not retry.
        return;
      }
      // Handle other errors with retry logic
    } catch (error) {
      console.error('Request failed:', error);
    }
    ```
  </Accordion>

  <Accordion title="Use connection pooling" icon="plug">
    **Reuse HTTP connections to reduce latency and improve throughput.**

    * Configure HTTP clients to reuse connections
    * Set appropriate connection pool sizes (e.g., 10-50 connections)
    * Enable keep-alive headers
    * Use persistent connections for high-volume applications
    * Monitor connection pool metrics

    ```python Example with Python requests theme={null}
    import requests
    from requests.adapters import HTTPAdapter

    session = requests.Session()
    adapter = HTTPAdapter(pool_connections=20, pool_maxsize=20)
    session.mount('https://', adapter)

    # Reuse session for all requests
    response = session.get(url, headers=headers)
    ```
  </Accordion>
</AccordionGroup>

***

## Next steps

<CardGroup cols={2}>
  <Card title="REST API reference" icon="book" href="/api-reference/introduction">
    Explore all available endpoints and their parameters
  </Card>

  <Card title="Streaming API" icon="signal-stream" href="/streaming/introduction">
    Real-time token price updates over Server-Sent Events. On Pro, connect to streaming-pro.dexpaprika.com.
  </Card>

  <Card title="Tutorials" icon="graduation-cap" href="/tutorials/tutorial_intro">
    Learn how to build applications with DexPaprika
  </Card>

  <Card title="Coverage checker" icon="magnifying-glass-chart" href="/tools/coverage-checker">
    Check which tokens and pools are available in our database
  </Card>
</CardGroup>

***

## Get support

<CardGroup cols={2}>
  <Card title="Enterprise support" icon="headset" href="mailto:support@coinpaprika.com">
    Get priority technical support from our engineering team
  </Card>

  <Card title="Join Discord" icon="discord" href="https://discord.gg/DhJge5TUGM">
    Connect with our community for general questions
  </Card>
</CardGroup>

***

## FAQs

<AccordionGroup>
  <Accordion title="How do I get a Pro API key?">
    Sign up at [console.dexpaprika.com](https://console.dexpaprika.com), subscribe to Pro, and copy the key from the Keys page. No sales call and no waiting. Enterprise is the exception: those limits are agreed per contract, so email [support@coinpaprika.com](mailto:support@coinpaprika.com).
  </Accordion>

  <Accordion title="Can I use both the free and the Pro API at once?">
    You can call `api.dexpaprika.com` without a key from the same application, and that keyless
    traffic is metered on free-tier terms. Your paid key belongs on `api-pro.dexpaprika.com`.
    The monthly credit allowance, overage handling, real-time data and the 99.5% SLA are all
    attached to the paid hosts, so paid traffic sent anywhere else is paying for entitlements
    it is not receiving.
  </Accordion>

  <Accordion title="What are the Pro limits?">
    5,000,000 credits a month included, at up to 500 requests a minute, with \$20 per additional 1M beyond that. One request costs one credit, batch endpoints cost one credit per item, and each streaming update delivered costs one credit. Enterprise raises both numbers to fit your workload. See [rate limits](/knowledge-base/rate-limits) and [pricing](https://dexpaprika.com/api/pricing); these numbers move.
  </Accordion>

  <Accordion title="What happens if my API key is compromised?">
    Regenerate it yourself from the Keys page in the console. Because each account has exactly one key, regenerating replaces the old one immediately, so plan a moment when you can redeploy: every integration using the old key stops working at once. If you cannot get into the account, email [support@coinpaprika.com](mailto:support@coinpaprika.com).
  </Accordion>

  <Accordion title="Do you offer dedicated infrastructure or on-premise deployment?">
    Yes, we can provide custom infrastructure solutions for enterprise customers. Contact our sales team to discuss your specific requirements.
  </Accordion>

  <Accordion title="How do I tell whether the problem is me or you?">
    Two different questions, two different calls. `GET /usage` tells you which plan and which
    host you are really talking to, and it is never served from cache, so it is the one to
    reach for when a key or a base URL is in doubt. Separately, every host answers `GET /health`
    with a plain up or down for the service itself. It takes no key and says nothing about your
    key, your plan or your host, so it only answers "is the service running", never "is my
    request right".
  </Accordion>

  <Accordion title="Is the data the same as the free API?">
    The coverage is identical: same endpoints, same chains, same history. The difference is freshness. The free tier is served with a delay of up to 60 seconds; Pro is real time. Pro also adds dedicated infrastructure, a much higher credit allowance, a 99.5% SLA and priority support.
  </Accordion>
</AccordionGroup>

<script type="application/ld+json">
  {JSON.stringify({
      "@context": "https://schema.org",
      "@type": "FAQPage",
      "mainEntity": [
        {"@type": "Question","name": "How do I get a Pro API key?","acceptedAnswer": {"@type": "Answer","text": "Pro is self-serve. Sign up at console.dexpaprika.com, subscribe to Pro at $99 per month, and copy the key from the Keys page. Enterprise limits are agreed per contract, so those start with an email to support@coinpaprika.com."}},
        {"@type": "Question","name": "Can I use both the free and the Pro API at once?","acceptedAnswer": {"@type": "Answer","text": "You can call api.dexpaprika.com without a key from the same application, metered on free-tier terms. Your paid key belongs on api-pro.dexpaprika.com: the monthly credit allowance, overage handling, real-time data and the 99.5% SLA are attached to the paid hosts."}},
        {"@type": "Question","name": "How do I tell whether a DexPaprika problem is my request or the service?","acceptedAnswer": {"@type": "Answer","text": "GET /usage tells you which plan and host you are really talking to and is never served from cache, so use it when a key or base URL is in doubt. Every host also answers GET /health with a plain up or down for the service itself, which takes no key and says nothing about your key, plan or host."}},
        {"@type": "Question","name": "What are the Pro limits?","acceptedAnswer": {"@type": "Answer","text": "Pro includes 5,000,000 credits a month at up to 500 requests a minute, with $20 per additional 1M beyond that. One request costs one credit, batch endpoints cost one credit per item, and each streaming update costs one credit."}},
        {"@type": "Question","name": "What happens if my API key is compromised?","acceptedAnswer": {"@type": "Answer","text": "Regenerate it yourself from the Keys page in the console. Each account has exactly one key, so regenerating replaces the old one immediately and every integration using it needs the new value. If you cannot get into the account, email support@coinpaprika.com."}},
        {"@type": "Question","name": "Do you offer dedicated infrastructure or on-premise deployment?","acceptedAnswer": {"@type": "Answer","text": "Yes, we can provide custom infrastructure solutions for enterprise customers. Contact our sales team to discuss your specific requirements."}},
        {"@type": "Question","name": "Is the data the same as the free API?","acceptedAnswer": {"@type": "Answer","text": "Coverage is identical: same endpoints, chains and history. The free tier is served with a delay of up to 60 seconds; Pro is real time and adds a 99.5% SLA, dedicated infrastructure and priority support."}}
      ]
    })}
</script>