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

# Get RSI for a token.

> Relative Strength Index, 0 to 100, from candle closes.
Computed from completed token OHLCV candles.

**Paid plans only.** Available on Dev, Pro and Enterprise keys.
Keyless requests and free keys receive HTTP 403.

Without `start` the response holds the last `limit` candles. When
`limit` cuts the range, `next_cursor` holds the start of the next page.




## OpenAPI

````yaml /api-reference/openapi.yml get /networks/{network}/tokens/{token_address}/indicators/rsi
openapi: 3.1.0
info:
  title: DexPaprika API
  version: 1.0.4
  description: >
    # Introduction
      Welcome to the DexPaprika API! This product is developed by [CoinPaprika](https://coinpaprika.com).

      Our API enables developers to query token, pool, and DEX data across multiple blockchain networks. Feel free to explore our endpoints below.

      ---
    # Rate limits and credit quota
      Two different limits apply, signalled by distinct status codes:

      - **429 Too Many Requests**, you are sending requests too fast (per-minute limit). Slow down and retry after the number of seconds given in the `Retry-After` header.

      - **402 Payment Required**, your credit allowance is exhausted. Retrying will not help. Register a free key (keyless), upgrade your plan (free key), or enable overage in the console (Dev and Pro).

      Both codes carry a structured JSON body (`error`, `tier`, `message`, `credits`, and per-scenario fields; see the 402/429 response schemas below). A Dev or Pro 402 includes `resets_at`, the UTC end of the billing period; keyless and free keys count over a rolling 30-day window and carry no `resets_at`. A 402 deliberately carries no `Retry-After` header.

      Responses include an `X-Api-Plan` header naming the plan the request was evaluated against, `x-credits-limit`, `x-credits-remaining` and `x-credits-reset` for the credit allowance, and the `ratelimit-limit`, `ratelimit-remaining` and `ratelimit-reset` trio.

      Call `GET /usage` to check your plan and, when authenticated with an API key on `api-pro.dexpaprika.com`, your current-period credit usage and remaining allowance.

      ---
    # Getting started

    ## Testing the API with code snippets

    The snippets below show how to quickly make a **GET** request. No API key is
    needed to start, so you can call the endpoints directly.


    > **Note**: If you see CORS issues in a browser, you may need to call these
    endpoints from a backend server to avoid local browser restrictions.


    ### 1. cURL


    ```bash

    curl -X GET
    "https://api.dexpaprika.com/networks/ethereum/pools/search?limit=10" | jq

    ```

    ### 2. Node.js (JavaScript)

    ```js

    const https = require('https');


    const options = {
      hostname: 'api.dexpaprika.com',
      path: '/networks/ethereum/pools/search?limit=10',
      method: 'GET',
    };


    const req = https.request(options, res => {
      let data = '';
      res.on('data', chunk => { data += chunk; });
      res.on('end', () => { console.log(JSON.parse(data)); });
    });


    req.on('error', error => { console.error(error); });

    req.end();

    ```


    ### 3. Python

    ```python

    import requests


    url = "https://api.dexpaprika.com/networks/ethereum/pools/search?limit=10"


    response = requests.get(url)

    if response.status_code == 200:
        print(response.json())
    else:
        print(f"Error: {response.status_code} -> {response.text}")
    ```

    ### 4. PHP

    ```php

    <?php

    $curl = curl_init();


    curl_setopt_array($curl, array(
      CURLOPT_URL => "https://api.dexpaprika.com/networks/ethereum/pools/search?limit=10",
      CURLOPT_RETURNTRANSFER => true
    ));


    $response = curl_exec($curl);


    if(curl_errno($curl)) {
      echo "Error: " . curl_error($curl);
    } else {
      echo $response;
    }


    curl_close($curl);

    ?>

    ```


    ### 5. Java

    ```java

    import java.io.*;

    import java.net.HttpURLConnection;

    import java.net.URL;


    public class DexPaprikaExample {
        public static void main(String[] args) {
            try {
                URL url = new URL("https://api.dexpaprika.com/networks/ethereum/pools/search?limit=10");
                HttpURLConnection con = (HttpURLConnection) url.openConnection();
                con.setRequestMethod("GET");
                int responseCode = con.getResponseCode();
                try (BufferedReader in = new BufferedReader(new InputStreamReader(con.getInputStream()))) {
                    String inputLine;
                    StringBuilder content = new StringBuilder();
                    while ((inputLine = in.readLine()) != null) {
                        content.append(inputLine);
                    }
                    if (responseCode == 200) {
                        System.out.println(content.toString());
                    } else {
                        System.out.println("Error: " + responseCode);
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    ```


    ### 6. Go

    ```go

    package main


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


    func main() {
        client := &http.Client{}
        req, err := http.NewRequest("GET", "https://api.dexpaprika.com/networks/ethereum/pools/search?limit=10", nil)
        if err != nil {
            log.Fatal(err)
        }

        resp, err := client.Do(req)
        if err != nil {
            log.Fatal(err)
        }
        defer resp.Body.Close()

        body, err := ioutil.ReadAll(resp.Body)
        if err != nil {
            log.Fatal(err)
        }

        if resp.StatusCode == http.StatusOK {
            fmt.Println(string(body))
        } else {
            fmt.Printf("Error: %d -> %s\n", resp.StatusCode, body)
        }
    }

    ```


    ### 7. C#

    ```csharp

    using System;

    using System.Net.Http;

    using System.Threading.Tasks;


    class Program

    {
        static async Task Main()
        {
            using var client = new HttpClient();
            var url = "https://api.dexpaprika.com/networks/ethereum/pools/search?limit=10";
            
            var response = await client.GetAsync(url);
            
            if (response.IsSuccessStatusCode)
            {
                var content = await response.Content.ReadAsStringAsync();
                Console.WriteLine(content);
            }
            else
            {
                Console.WriteLine($"Error: {response.StatusCode}");
            }
        }
    }

    ```


    ## Feedback and next steps

    1. **Test** any of the snippets above.  

    2. **Explore** our other endpoints in this documentation.   

    3. **Share** your feedback with us at
    [support@coinpaprika.com](mailto:support@coinpaprika.com).

    4. If you want implement our API into your project or simply discuss
    possible collaboration, please reach out to msroka@coinpaprika.com.

    ---
  contact:
    name: CoinPaprika Support
    email: support@coinpaprika.com
    url: https://coinpaprika.com
  license:
    name: Proprietary
    url: https://dexpaprika.com/terms
servers:
  - url: https://api.dexpaprika.com
    description: Production server
security: []
tags:
  - name: Networks
    description: Endpoints for retrieving information about supported blockchain networks
  - name: DEXes
    description: Endpoints for retrieving information about decentralized exchanges
  - name: Pools
    description: Endpoints for retrieving information about liquidity pools
  - name: Tokens
    description: Endpoints for retrieving information about tokens
  - name: Search
    description: Endpoints for searching across tokens, pools, and DEXes
  - name: Utils
    description: Utility endpoints for system metadata
paths:
  /networks/{network}/tokens/{token_address}/indicators/rsi:
    get:
      tags:
        - Tokens
      summary: Get RSI for a token.
      description: |
        Relative Strength Index, 0 to 100, from candle closes.
        Computed from completed token OHLCV candles.

        **Paid plans only.** Available on Dev, Pro and Enterprise keys.
        Keyless requests and free keys receive HTTP 403.

        Without `start` the response holds the last `limit` candles. When
        `limit` cuts the range, `next_cursor` holds the start of the next page.
      operationId: getTokenRSI
      parameters:
        - $ref: '#/components/parameters/networkParam'
        - $ref: '#/components/parameters/tokenAddressParam'
        - $ref: '#/components/parameters/indicatorIntervalParam'
        - $ref: '#/components/parameters/indicatorLimitParam'
        - $ref: '#/components/parameters/indicatorStartParam'
        - $ref: '#/components/parameters/indicatorEndParam'
        - $ref: '#/components/parameters/indicatorCursorParam'
        - $ref: '#/components/parameters/rsiPeriodParam'
      responses:
        '200':
          description: RSI values, oldest first.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/IndicatorResponse'
              example:
                network: ethereum
                token_address: '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2'
                indicator: rsi
                interval: 1h
                parameters:
                  period: 14
                data:
                  - timestamp: '2026-10-07T10:00:00Z'
                    value: 58.21
                has_next_page: false
                next_cursor: ''
        '400':
          $ref: '#/components/responses/BadRequest'
        '402':
          $ref: '#/components/responses/QuotaExceeded'
        '403':
          $ref: '#/components/responses/PaidPlanRequired'
        '404':
          $ref: '#/components/responses/NotFound'
        '429':
          $ref: '#/components/responses/RateLimited'
components:
  parameters:
    networkParam:
      name: network
      in: path
      required: true
      schema:
        type: string
      description: >-
        Network slug or ID (e.g., 'solana'). You can find the list of supported
        networks with their IDs here: [/networks](/api-reference/networks).
      example: solana
    tokenAddressParam:
      name: token_address
      in: path
      required: true
      schema:
        type: string
      description: >-
        Token contract address. Such as
        `JUPyiwrYJFskUPiHa7hkeR8VUtAeFoSYbKedZNsDvCN` for Jupiter on Solana.
      example: JUPyiwrYJFskUPiHa7hkeR8VUtAeFoSYbKedZNsDvCN
    indicatorIntervalParam:
      name: interval
      in: query
      required: false
      schema:
        type: string
        enum:
          - 1m
          - 5m
          - 10m
          - 15m
          - 30m
          - 1h
          - 6h
          - 12h
          - 24h
          - 1d
        default: 24h
      description: Candle interval the indicator is computed on. `1d` is the same as `24h`.
    indicatorLimitParam:
      name: limit
      in: query
      required: false
      schema:
        type: integer
        default: 100
        minimum: 1
        maximum: 1000
      description: Maximum number of values to return.
    indicatorStartParam:
      name: start
      in: query
      required: false
      example: '-7d'
      schema:
        type: string
      description: >-
        First candle to return. Unix seconds, a relative offset from now such as
        `-24h` with units s, m, h, d, RFC3339 or a date at 00:00 UTC. Defaults
        to `limit` candles before `end`, cut to the last 7 days for keyless
        callers and free keys.
    indicatorEndParam:
      name: end
      in: query
      required: false
      schema:
        type: string
      description: >-
        End of the range, exclusive. Same formats as `start`. Must not be in the
        future. Defaults to now.
    indicatorCursorParam:
      name: cursor
      in: query
      required: false
      schema:
        type: string
      description: The `next_cursor` of the previous page. Cannot be combined with `start`.
    rsiPeriodParam:
      name: period
      in: query
      required: false
      schema:
        type: integer
        default: 14
        minimum: 2
        maximum: 200
      description: Number of candles in the RSI window.
  schemas:
    IndicatorResponse:
      type: object
      properties:
        network:
          type: string
        pool_address:
          type: string
          description: Set on pool indicators.
        token_address:
          type: string
          description: Set on token indicators.
        indicator:
          type: string
          enum:
            - rsi
            - ema
            - macd
            - bbands
            - vwap
        interval:
          type: string
        parameters:
          type: object
          additionalProperties: true
          description: Indicator parameters used, defaults included.
        data:
          type: array
          items:
            type: object
            required:
              - timestamp
            properties:
              timestamp:
                type: string
                format: date-time
                description: Open time of the candle.
            additionalProperties:
              type: number
            description: >-
              One value per candle. RSI, EMA and VWAP return `value`, MACD
              returns `macd`, `signal` and `histogram`, Bollinger Bands return
              `upper`, `middle` and `lower`.
        has_next_page:
          type: boolean
        next_cursor:
          type: string
          description: Pass as `cursor` to get the next page. Empty on the last page.
    ErrorBody:
      type: object
      description: >
        Envelope of every error response that has no more specific body. Branch
        on `error`, which is stable; `message` is human-readable copy that may
        change.
      required:
        - error
        - message
      properties:
        error:
          type: string
          enum:
            - invalid_param
            - missing_param
            - unauthorized
            - invalid_api_key
            - forbidden
            - not_found
            - unsupported_network
            - route_not_found
            - method_not_allowed
            - endpoint_removed
            - rate_limited
            - internal_error
            - unavailable
          description: Machine-readable error code.
        message:
          type: string
          description: Human-readable description.
        param:
          type: string
          description: The query or path parameter that caused the error.
        resource:
          type: string
          description: What a 404 could not find (pool, token, dex).
    QuotaErrorBody:
      type: object
      description: >
        Structured body carried by every 402 and 429 emitted by the billing gate
        and by plan-gated 403s. The shape is constant across scenarios; only
        fields describing an available action appear. `message` is always a
        top-level string, so clients parsing the legacy `{"message": ...}` shape
        keep working.
      required:
        - error
        - tier
        - message
      properties:
        error:
          type: string
          enum:
            - payment_required
            - rate_limited
            - plan_required
            - wrong_host
            - preview_only
          description: Machine-readable discriminator.
        tier:
          type: string
          enum:
            - keyless
            - free
            - dev
            - pro
            - enterprise
          description: The billing tier the request was evaluated against.
        message:
          type: string
          description: Human-readable message naming the next action.
        required_tier:
          type: string
          enum:
            - free
            - dev
            - pro
          description: Lowest tier that unlocks the request. plan_required only.
        param:
          type: string
          description: >
            Query parameter that exceeded the plan. plan_required only; absent
            when the whole endpoint is gated.
        credits:
          type: object
          description: >
            Credit counters for the current period. One credit is one request.
            `plan` and `packs` are split out for Pro keys only. `limit` is plan
            + packs; usage served through overage can exceed it.
          properties:
            plan:
              type: integer
              format: int64
            packs:
              type: integer
              format: int64
            limit:
              type: integer
              format: int64
            used:
              type: integer
              format: int64
            remaining:
              type: integer
              format: int64
        overage:
          type: object
          description: >
            Overage state, present on Pro 402 bodies. Money amounts are decimal
            strings, never floats.
          properties:
            enabled:
              type: boolean
            cap:
              type: string
              example: '200.00'
            used:
              type: string
              example: '200.00'
            block:
              type: string
              example: 20.00 per 1M credits
        resets_at:
          type: string
          format: date-time
          description: When the monthly allowance rolls over (UTC). 402 only.
        retry_after:
          type: integer
          description: Seconds to wait before retrying. 429 only.
        offer:
          type: object
          description: Early-adopter offer, present on the free-tier 402 only.
          properties:
            description:
              type: string
            expires_at:
              type: string
              format: date-time
        links:
          type: object
          additionalProperties:
            type: string
          description: >
            Next-step URLs. Keys vary by scenario: register, upgrade, packs,
            portal, usage, docs. Absent until the customer-facing pages go live.
  responses:
    BadRequest:
      description: >
        A query or path parameter is missing or invalid. `param` names it;
        `error` is `missing_param` when a required parameter is absent and
        `invalid_param` otherwise.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/ErrorBody'
          examples:
            invalid:
              summary: Value out of range
              value:
                error: invalid_param
                message: 'invalid query parameters: limit (must be at most 100)'
                param: limit
            missing:
              summary: Required parameter absent
              value:
                error: missing_param
                message: 'invalid query param: start (is required)'
                param: start
    QuotaExceeded:
      description: >
        Credit allowance exhausted. Retrying will not help; the body names the
        available next step per tier: register (keyless), upgrade (free key), or
        enable overage and raise your spend cap (Dev and Pro). `resets_at` is
        present on Dev and Pro only and holds the end of the billing period
        (UTC); keyless and free keys count over a rolling 30-day window.
        Deliberately carries no `Retry-After` header.
      headers:
        X-Credits-Limit:
          description: Monthly credit limit for this caller.
          schema:
            type: integer
        X-Credits-Remaining:
          description: Credits left in the current month.
          schema:
            type: integer
        X-Credits-Reset:
          description: Seconds until the monthly credits reset.
          schema:
            type: integer
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/QuotaErrorBody'
          examples:
            keyless:
              summary: Keyless client over the rolling 30-day limit
              value:
                error: payment_required
                tier: keyless
                message: >-
                  Credit limit for the last 30 days reached for unauthenticated
                  use. Register for a free API key to get more credits/month.
                credits:
                  limit: 10000
                  used: 10000
                  remaining: 0
            pro_plan_exhausted:
              summary: Pro key with plan credits drained, overage off
              value:
                error: payment_required
                tier: pro
                message: Monthly credit limit reached — enable overage in the portal.
                credits:
                  plan: 5000000
                  packs: 0
                  limit: 5000000
                  used: 5000000
                  remaining: 0
                overage:
                  enabled: false
                resets_at: '2026-09-01T00:00:00Z'
    PaidPlanRequired:
      description: >
        The endpoint is limited to paid plans (Dev, Pro, Enterprise). Keyless
        callers and free keys are refused regardless of remaining credits;
        upgrading the key's plan is the only way to unlock it. `param` is absent
        because the whole endpoint is gated.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/QuotaErrorBody'
          example:
            error: plan_required
            tier: free
            required_tier: dev
            message: this endpoint requires a Dev or Pro plan
    NotFound:
      description: >
        The network is not supported (`unsupported_network`) or the requested
        resource does not exist (`not_found`, with `resource` naming it).
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/ErrorBody'
          examples:
            resource:
              summary: Unknown pool
              value:
                error: not_found
                message: pool not found
                resource: pool
            network:
              summary: Unknown network
              value:
                error: unsupported_network
                message: unsupported network
                param: network
    RateLimited:
      description: >
        Per-minute rate limit exceeded. Slow down and retry after the number of
        seconds given in the `Retry-After` header. Credits are unaffected;
        `credits` appears in the body only when the counters were already at
        hand for the request.
      headers:
        Retry-After:
          description: Seconds to wait before retrying.
          schema:
            type: integer
        RateLimit-Limit:
          description: Request limit for the current minute.
          schema:
            type: integer
        RateLimit-Remaining:
          description: Requests left in the current minute.
          schema:
            type: integer
        RateLimit-Reset:
          description: Seconds until the minute limit resets.
          schema:
            type: integer
        X-Credits-Limit:
          description: Monthly credit limit for this caller.
          schema:
            type: integer
        X-Credits-Remaining:
          description: Credits left in the current month.
          schema:
            type: integer
        X-Credits-Reset:
          description: Seconds until the monthly credits reset.
          schema:
            type: integer
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/QuotaErrorBody'
          example:
            error: rate_limited
            tier: pro
            message: Request rate exceeded. Retry in 12 seconds.
            credits:
              plan: 5000000
              packs: 0
              limit: 5000000
              used: 1240880
              remaining: 3759120
            retry_after: 12

````

This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.