> ## 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.

# DexPaprika Pro API - authenticated access for paid plans

> Authenticated DEX and on-chain data for paid plans: 5,000,000 credits a month, 300 requests a minute, real-time data, dedicated infrastructure, and priority support. API key access on api-pro.dexpaprika.com.

<Note>
  **Just getting started?** The standard API at `api.dexpaprika.com` needs no key to start and is the right place to build first. This page is for paid plans, which authenticate against `api-pro.dexpaprika.com` with an API key. See [rate limits](/knowledge-base/rate-limits) for the credit allowances and [pricing](https://dexpaprika.com/api/pricing) for plans.
</Note>

## What is the Pro API?

The Pro API serves the same DEX and on-chain data as the standard API, on a separate authenticated host, with a higher credit allowance, real-time data instead of the free tier's 15 second delay, a 99.5% SLA and priority support. Enterprise uses this same API and the same onboarding, with limits raised to whatever your workload needs.

<CardGroup cols={2}>
  <Card title="Room to scale" icon="gauge-high">
    5,000,000 credits a month at 300 requests a minute, against 300,000 at 30 on a free key. Enterprise lifts both to custom levels.
  </Card>

  <Card title="Dedicated Infrastructure" icon="server">
    Separate infrastructure ensuring consistent performance and availability
  </Card>

  <Card title="Priority Support" icon="headset">
    Direct access to our engineering team for technical assistance
  </Card>

  <Card title="API Key Authentication" icon="key">
    Secure access control and usage tracking for your organization
  </Card>
</CardGroup>

***

## 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 -X GET "https://api-pro.dexpaprika.com/networks/ethereum/pools/search" \
      -H "Content-Type: application/json" \
      -H "Authorization: api_YOUR_API_KEY_HERE"
  ```

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

  headers = {
      "Content-Type": "application/json",
      "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 = {
    'Content-Type': 'application/json',
    '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("Content-Type", "application/json")
      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
```

Always prefix your key with `api_` when using it in the Authorization header.

***

## 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                                |
| **Monthly credits**     | 50,000 keyless, 300,000 with a free key | 5,000,000 included, then \$20 per additional 1M |
| **Requests per minute** | 30                                      | 300                                             |
| **Max data delay**      | 15 seconds                              | real time                                       |
| **SLA**                 | best effort                             | 99.5%                                           |
| **Infrastructure**      | Shared                                  | Dedicated                                       |
| **Support**             | Community                               | Priority support                                |
| **Endpoints**           | All endpoints                           | All endpoints                                   |

Credit detail lives on the [rate limits page](/knowledge-base/rate-limits), and plans on [pricing](https://dexpaprika.com/api/pricing). There are no feature gates: every endpoint, all history and all 36 chains are on the free tier too. The rows above are the whole difference. **Enterprise is this same API with the limits raised for your workload**, so everything below applies unchanged.

<Tip>
  All 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 -X GET "https://api-pro.dexpaprika.com/networks/solana/tokens/So11111111111111111111111111111111111111112" \
        -H "Content-Type: application/json" \
        -H "Authorization: api_YOUR_API_KEY_HERE"
    ```
  </Step>

  <Step title="Receive the response">
    You'll get the same comprehensive data as the free API:

    ```json Response [expandable] theme={null}
    {
      "id": "So11111111111111111111111111111111111111112",
      "name": "Wrapped SOL",
      "symbol": "SOL",
      "chain": "solana",
      "decimals": 9,
      "total_supply": 0,
      "has_image": true,
      "summary": {
        "price_usd": 165.0363416231933,
        "fdv": 21277129298.9034355594499,
        "liquidity_usd": 21277129298.9034355594499,
        "pools": 12543,
        "24h": {
          "volume": 18207227.90283451,
          "volume_usd": 3172926820.723157,
          "sells": 11953376,
          "buys": 8641848,
          "txns": 20595327,
          "buy_usd": 1586463410.3615785,
          "sell_usd": 1586463410.3615785,
          "last_price_usd_change": 2.5
        }
      }
    }
    ```
  </Step>
</Steps>

***

## Error handling

### Authentication errors

<AccordionGroup>
  <Accordion title="403 Forbidden - Missing or invalid API key">
    **Error response:**

    ```json theme={null}
    {
      "message": "Forbidden"
    }
    ```

    **Solution:** Ensure you're including the `Authorization` header with a valid API key in the format `api_YOUR_KEY`.
  </Accordion>

  <Accordion title="401 Unauthorized - Malformed API key">
    **Error response:**

    ```json theme={null}
    {
      "message": "Unauthorized"
    }
    ```

    **Solution:** Check that your API key follows the correct format: `api_` prefix followed by your key string.
  </Accordion>
</AccordionGroup>

### Other errors

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

* `400 Bad Request` - Invalid parameters
* `402 Payment Required` - monthly credit allowance exhausted. Retrying does not help. Buy a credit pack or enable overage in [console.dexpaprika.com](https://console.dexpaprika.com). 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-token-prices-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

Migrating from the free API to Pro API is straightforward:

<Steps>
  <Step title="Update base URL">
    Replace all instances of:

    ```
    https://api.dexpaprika.com
    ```

    With:

    ```
    https://api-pro.dexpaprika.com
    ```
  </Step>

  <Step title="Add authentication header">
    Add the `Authorization` header to every request:

    ```javascript theme={null}
    headers: {
      'Authorization': 'api_YOUR_API_KEY_HERE'
    }
    ```
  </Step>

  <Step title="Retune your rate limiting">
    Pro raises the per-minute ceiling from 30 to 300, so throttling tuned for the free tier is now far too conservative. Keep the throttle and the 429 backoff, just raise the threshold. On Enterprise, set it to whatever your contract allows.
  </Step>

  <Step title="Test your integration">
    Make test requests to verify your API key works correctly and you're receiving expected responses.
  </Step>
</Steps>

***

## 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 /usage` from your own code
    * 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.**

    * Catch and handle 403/401 errors separately from other errors
    * Implement exponential backoff for transient failures
    * Don't retry on authentication errors - fix the key instead
    * 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) {
        console.error('Invalid API key - check your credentials');
        // Don't retry - fix the key
        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 via Server-Sent Events
  </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 free and Pro API simultaneously?">
    Yes, you can use both APIs in the same application. The free API requires no authentication, while the Pro API requires your API key.
  </Accordion>

  <Accordion title="What are the Pro limits?">
    5,000,000 credits a month included, at up to 300 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).
  </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="Is the data the same as the free API?">
    The coverage is identical: same endpoints, same chains, same history, no feature gates. The difference is freshness. The free tier is served with a delay of up to 15 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 free and Pro API simultaneously?","acceptedAnswer": {"@type": "Answer","text": "Yes, you can use both APIs in the same application. The free API requires no authentication, while the Pro API requires your API key."}},
        {"@type": "Question","name": "What are the DexPaprika Pro API limits?","acceptedAnswer": {"@type": "Answer","text": "Pro includes 5,000,000 credits a month at up to 300 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": "Contact support@coinpaprika.com immediately to revoke your current key and receive a new one."}},
        {"@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, no feature gates. The free tier is served with a delay of up to 15 seconds; Pro is real time and adds a 99.5% SLA, dedicated infrastructure and priority support."}}
      ]
    })}
</script>