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

# Prices · Spot OHLC

> Pull time-bucketed OHLC bars from executed swap prices per pool.

<Warning>
  **Not available on the public API yet:** This endpoint is scheduled to become available **by the end of May 2026**. Until then, calls may fail (for example with `404`, `403`, or `501`). For early access or contract timelines, contact [support@blockdb.io](mailto:support@blockdb.io).
</Warning>

## Overview

* **Dataset ID:** [`0404 - Token-to-Token OHLC`](/data-catalog/evm/prices/token-to-token-prices-ohlc)
* **Description:** Time-bucketed OHLC bars (1m..1d) per pool and token pair direction.
* **CSV Sample:** [Download](https://huggingface.co/datasets/BlockDB/Token-Prices-OHLC-Ethereum-And-EVM-Cryptocurrency-Data/resolve/main/data/blockdb_evm.b0404_token_to_token_prices_ohlc_v1.csv?download=true)
* **JSON Sample:** [Download](https://huggingface.co/datasets/BlockDB/Token-Prices-OHLC-Ethereum-And-EVM-Cryptocurrency-Data/resolve/main/data/blockdb_evm.b0404_token_to_token_prices_ohlc_v1.json?download=true)

## Parameters

<ParamField body="chain_id" type="number" required>
  Target EVM chain. *See the [Chain](/api-reference/enumerations/chain) enumeration for supported values.*
</ParamField>

<ParamField body="base_token_address" type="string" required>
  ERC-20 contract address for the base asset (hex string, 20 bytes, no `0x` prefix).
</ParamField>

<ParamField body="quote_token_address" type="string" required>
  ERC-20 contract address for the quote asset (hex string, 20 bytes, no `0x` prefix).
</ParamField>

#### Range Filters (mutually exclusive)

<ParamField body="from_block" type="number">
  Starting block (inclusive). Block ranges use **strict containment**: only buckets whose entire span maps to blocks within `[from_block, to_block]` are returned, so each bar aggregates only blocks inside your range. The partial bucket that merely contains `from_block` (and also spans earlier blocks) is excluded. A range narrower than one `bucket_seconds` returns no bars. Use with `to_block`.
</ParamField>

<ParamField body="to_block" type="number">
  Ending block (inclusive). The partial bucket that contains `to_block` (and also spans later blocks) is excluded — only buckets ending at or before `to_block`'s timestamp are returned. Use with `from_block`.
</ParamField>

<ParamField body="from_timestamp" type="string">
  Window start (ISO-8601, inclusive). Used directly as `bucket_start >= from_timestamp`. Use with `to_timestamp`.
</ParamField>

<ParamField body="to_timestamp" type="string">
  Window end (ISO-8601, inclusive). Buckets with `bucket_end <= to_timestamp` are included. Use with `from_timestamp`.
</ParamField>

<Warning>
  Provide **either** a block range (`from_block` + `to_block`) **or** a time range (`from_timestamp` + `to_timestamp`), not both. Omitting both is HTTP 400.
</Warning>

#### Direct Selectors

<ParamField body="exchange_ids" type="number[]">
  Filter by exchange identifiers. *See the [DigitalExchange](/api-reference/enumerations/digital-exchange) enumeration.*
</ParamField>

<ParamField body="pool_uids" type="string[]">
  Restrict to specific BlockDB pool identifiers.
</ParamField>

#### Candle Controls

<ParamField body="bucket_seconds" type="number" required>
  Candle width in seconds. Allowed values: `60`, `300`, `900`, `1800`, `3600`, `14400`, `86400`.
</ParamField>

<ParamField body="dense" type="boolean" default="false">
  Gap-fill: one row per pool per bucket in the requested window. Gap buckets LOCF the last `close` (flat candle: open=high=low=close), with zero volumes and `trades_count=0`.

  Eligible pools have at least one bar for this pair and `bucket_seconds` on or before the window end (same `0404` table). LOCF seeds from the last bar before the window start when available, then from in-window bars.

  Works with a timestamp or block range (blocks resolve to timestamps, then align to bucket boundaries).
</ParamField>

#### Pagination Controls

<ParamField body="limit" type="number" default="250">
  Recommended default `250`; maximum `1000` to stay under \~10 MB responses.
</ParamField>

<ParamField body="cursor" type="string">
  Opaque pagination cursor supplied by a previous response.
</ParamField>

## Response Fields

#### Meta

<ResponseField name="meta" type="object">
  Echo of request metadata applied to the response.
</ResponseField>

<ResponseField name="meta.chain_id" type="number">
  EVM chain ID echoed from the request.
</ResponseField>

<ResponseField name="meta.base_token_address" type="string">
  ERC-20 contract address of the base asset, echoed from the request.
</ResponseField>

<ResponseField name="meta.quote_token_address" type="string">
  ERC-20 contract address of the quote asset, echoed from the request.
</ResponseField>

<ResponseField name="meta.request_window" type="object">
  Pure echo of the window you sent (`from_block`/`to_block`/`from_timestamp`/`to_timestamp`); unset bounds are `null`.
</ResponseField>

<ResponseField name="meta.resolved_window" type="object | null">
  The concrete window the query actually executed against, after resolving the request. For a **block range** on a time-bucketed endpoint (OHLC/VWAP/VWAP-aggregate/fiat VWAP), `from_timestamp`/`to_timestamp` hold the resolved timestamp window (and `from_block`/`to_block` echo your request). For a **time range** on a block-keyed endpoint, `from_block`/`to_block` hold the resolved block range (and the timestamps echo your request). `null` for selector-only requests (no window). No extra database work is done — these are the values the query already computed.
</ResponseField>

<ResponseField name="meta.resolved_window.from_block" type="number | null">
  Resolved/echoed start block of the executed window.
</ResponseField>

<ResponseField name="meta.resolved_window.to_block" type="number | null">
  Resolved/echoed end block of the executed window.
</ResponseField>

<ResponseField name="meta.resolved_window.from_timestamp" type="string | null">
  Resolved/echoed start timestamp (ISO-8601) of the executed window.
</ResponseField>

<ResponseField name="meta.resolved_window.to_timestamp" type="string | null">
  Resolved/echoed end timestamp (ISO-8601) of the executed window.
</ResponseField>

<ResponseField name="meta.filters" type="object">
  Filter parameters echoed from the request.
</ResponseField>

#### Data

<ResponseField name="data" type="object[]">
  OHLC candles matching the request; each object uses the same field names as [`0404`](/data-catalog/evm/prices/token-to-token-prices-ohlc). When `dense=true`, one row is returned per pool per bucket for every bucket in the requested window.
</ResponseField>

<ResponseField name="data.pool_uid" type="string">
  BlockDB pool identifier for the candle.
</ResponseField>

<ResponseField name="data.exchange_id" type="number">
  Exchange/DEX identifier.
</ResponseField>

<ResponseField name="data.type_id" type="number">
  Pool type identifier.
</ResponseField>

<ResponseField name="data.bucket_start" type="string">
  Inclusive UTC start of the candle bucket (ISO-8601).
</ResponseField>

<ResponseField name="data.bucket_end" type="string">
  Exclusive UTC end of the candle bucket (ISO-8601). Equal to `bucket_start + bucket_seconds`.
</ResponseField>

<ResponseField name="data.bucket_seconds" type="number">
  Bucket width in seconds: `60`, `300`, `900`, `1800`, `3600`, `14400`, or `86400`.
</ResponseField>

<ResponseField name="data.open" type="string | null">
  Opening price for the bucket (`quote_token_address` per 1 `base_token_address`, decimals-adjusted). `null` only when no prior bar exists for this pool, pair, and `bucket_seconds` before the window ends.
</ResponseField>

<ResponseField name="data.high" type="string | null">
  Highest price within the bucket. `null` under the same condition as `open`.
</ResponseField>

<ResponseField name="data.low" type="string | null">
  Lowest price within the bucket. `null` under the same condition as `open`.
</ResponseField>

<ResponseField name="data.close" type="string | null">
  Closing price for the bucket. In dense mode, gap buckets LOCF the last `close` (including pre-window bars). `null` only when no LOCF seed exists.
</ResponseField>

<ResponseField name="data.volume_base_raw" type="string">
  Sum of raw UInt256 `amountIn` values. `"0"` for carry-forward buckets in dense mode.
</ResponseField>

<ResponseField name="data.volume_base" type="string | null">
  Decimal-adjusted base (`base_token_address`) volume. `null` when token decimals are unknown. `"0"` for carry-forward buckets in dense mode when decimals are known.
</ResponseField>

<ResponseField name="data.volume_quote_raw" type="string">
  Sum of raw UInt256 `amountOut` values. `"0"` for carry-forward buckets in dense mode.
</ResponseField>

<ResponseField name="data.volume_quote" type="string | null">
  Decimal-adjusted quote (`quote_token_address`) volume. `null` when token decimals are unknown. `"0"` for carry-forward buckets in dense mode when decimals are known.
</ResponseField>

<ResponseField name="data.trades_count" type="number">
  Trade count in the bucket. `0` for carry-forward buckets in dense mode.
</ResponseField>

<ResponseField name="data.block_bucket_first_block_number" type="number | null">
  First block number in the chain-wide bucket. Populated when `dense=true`; `null` in sparse mode.
</ResponseField>

<ResponseField name="data.block_bucket_last_block_number" type="number | null">
  Last block number in the chain-wide bucket. Populated when `dense=true`; `null` in sparse mode.
</ResponseField>

<ResponseField name="data.block_bucket_first_block_timestamp" type="string | null">
  Timestamp of the first block in the chain-wide bucket (ISO-8601). Populated when `dense=true`; `null` in sparse mode.
</ResponseField>

<ResponseField name="data.block_bucket_last_block_timestamp" type="string | null">
  Timestamp of the last block in the chain-wide bucket (ISO-8601). Populated when `dense=true`; `null` in sparse mode.
</ResponseField>

<ResponseField name="data.block_bucket_block_count" type="number | null">
  Block count in the chain-wide bucket. Populated when `dense=true`; `null` in sparse mode.
</ResponseField>

<ResponseField name="data._tracing_id" type="string | null">
  BlockDB tracing ID (hex, no `0x` prefix). `null` for synthetic gap-fill rows when `dense=true`.
</ResponseField>

<ResponseField name="data._parent_tracing_ids" type="string[] | null">
  Tracing IDs of contributing swap prints; optional. `null` for gap-fill rows and by default.
</ResponseField>

<ResponseField name="data._created_at" type="string | null">
  Record creation timestamp (ISO-8601). `null` for gap-fill rows.
</ResponseField>

<ResponseField name="data._updated_at" type="string | null">
  Record update timestamp (ISO-8601). `null` for gap-fill rows.
</ResponseField>

#### Envelope Fields

<ResponseField name="cursor" type="string | null">
  Pagination cursor.
</ResponseField>

<ResponseField name="page_count" type="number">
  Number of candles returned in this page.
</ResponseField>

### Usage Notes

* Pair direction is `meta.base_token_address` → `meta.quote_token_address` (`token_in` → `token_out`). Row objects do not repeat token addresses.
* For USD-denominated VWAP buckets, use [`/evm/prices/spot/fiat/vwap`](/api-reference/evm/prices/fiat/prices-spot-vwap-fiat) instead of this endpoint.
* Each row is one pool's candle for one bucket. Use `pool_uids` or `exchange_ids` to narrow results.
* `dense=true` works with a timestamp or block range.

<RequestExample>
  ```bash cURL theme={null}
  curl -X POST "https://api.blockdb.io/v1/evm/prices/spot/crypto/ohlc" \
    -H "Authorization: Bearer $BLOCKDB_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{
    "chain_id": 1,
    "base_token_address": "c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2",
    "quote_token_address": "a0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
    "from_timestamp": "2025-11-11T00:00:00Z",
    "to_timestamp": "2025-11-11T01:00:00Z",
    "exchange_ids": [1, 2],
    "bucket_seconds": 60,
    "dense": false,
    "limit": 200,
    "cursor": null
  }'
  ```

  ```c C theme={null}
  #include <curl/curl.h>
  #include <stdio.h>
  #include <stdlib.h>

  int main(void) {
      CURL *curl = curl_easy_init();
      if (!curl) return 1;

      const char *token = getenv("BLOCKDB_API_KEY");
      char auth_header[256];
      snprintf(auth_header, sizeof(auth_header), "Authorization: Bearer %s", token ? token : "");
      const char *payload = "{\"chain_id\":1,\"base_token_address\":\"c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2\",\"quote_token_address\":\"a0b86991c6218b36c1d19d4a2e9eb0ce3606eb48\",\"from_timestamp\":\"2025-11-11T00:00:00Z\",\"to_timestamp\":\"2025-11-11T01:00:00Z\",\"exchange_ids\":[1,2],\"bucket_seconds\":60,\"dense\":false,\"limit\":200,\"cursor\":null}";

      struct curl_slist *headers = NULL;
      headers = curl_slist_append(headers, auth_header);
      headers = curl_slist_append(headers, "Content-Type: application/json");


      curl_easy_setopt(curl, CURLOPT_URL, "https://api.blockdb.io/v1/evm/prices/spot/crypto/ohlc");
      curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
      curl_easy_setopt(curl, CURLOPT_POSTFIELDS, payload);


      CURLcode res = curl_easy_perform(curl);

      curl_slist_free_all(headers);
      curl_easy_cleanup(curl);
      return res == CURLE_OK ? 0 : 1;
  }
  ```

  ```csharp .NET theme={null}
  using System;
  using System.Net.Http;
  using System.Net.Http.Headers;
  using System.Text;
  using System.Threading.Tasks;

  class Program
  {
      static async Task Main()
      {
          using var client = new HttpClient();
          client.DefaultRequestHeaders.Authorization =
              new AuthenticationHeaderValue("Bearer", Environment.GetEnvironmentVariable("BLOCKDB_API_KEY"));

          var payload = new StringContent(
              "{\"chain_id\":1,\"base_token_address\":\"c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2\",\"quote_token_address\":\"a0b86991c6218b36c1d19d4a2e9eb0ce3606eb48\",\"from_timestamp\":\"2025-11-11T00:00:00Z\",\"to_timestamp\":\"2025-11-11T01:00:00Z\",\"exchange_ids\":[1,2],\"bucket_seconds\":60,\"dense\":false,\"limit\":200,\"cursor\":null}",
              Encoding.UTF8,
              "application/json"
          );

          var response = await client.PostAsync("https://api.blockdb.io/v1/evm/prices/spot/crypto/ohlc", payload);
          response.EnsureSuccessStatusCode();

          var body = await response.Content.ReadAsStringAsync();
          Console.WriteLine(body);
      }
  }
  ```

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

  payload = {
      "chain_id": 1,
      "base_token_address": "c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2",
      "quote_token_address": "a0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
      "from_timestamp": "2025-11-11T00:00:00Z",
      "to_timestamp": "2025-11-11T01:00:00Z",
      "exchange_ids": [1, 2],
      "bucket_seconds": 60,
      "dense": False,
      "limit": 200,
      "cursor": None
  }

  response = requests.post(
      "https://api.blockdb.io/v1/evm/prices/spot/crypto/ohlc",
      headers={
          "Authorization": f"Bearer {os.getenv('BLOCKDB_API_KEY')}",
          "Content-Type": "application/json"
      },
      json=payload
  )

  print(response.json())
  ```

  ```javascript Node.js theme={null}
  const response = await fetch("https://api.blockdb.io/v1/evm/prices/spot/crypto/ohlc", {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.BLOCKDB_API_KEY}`,
      "Content-Type": "application/json"
    },
    body: JSON.stringify({
    "chain_id": 1,
    "base_token_address": "c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2",
    "quote_token_address": "a0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
    "from_timestamp": "2025-11-11T00:00:00Z",
    "to_timestamp": "2025-11-11T01:00:00Z",
    "exchange_ids": [1, 2],
    "bucket_seconds": 60,
    "dense": false,
    "limit": 200,
    "cursor": null
  })
  });

  const data = await response.json();
  console.log(data);
  ```

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

  import (
      "fmt"
      "net/http"
      "os"
      "strings"
  )

  func main() {
      payload := strings.NewReader(`{
    "chain_id": 1,
    "base_token_address": "c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2",
    "quote_token_address": "a0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
    "from_timestamp": "2025-11-11T00:00:00Z",
    "to_timestamp": "2025-11-11T01:00:00Z",
    "exchange_ids": [1, 2],
    "bucket_seconds": 60,
    "dense": false,
    "limit": 200,
    "cursor": null
  }`)

      req, _ := http.NewRequest("POST", "https://api.blockdb.io/v1/evm/prices/spot/crypto/ohlc", payload)
      req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", os.Getenv("BLOCKDB_API_KEY")))
      req.Header.Set("Content-Type", "application/json")

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

      // Handle response
  }
  ```
</RequestExample>

<ResponseExample>
  ```json 200 theme={null}
  {
    "meta": {
      "chain_id": 1,
      "base_token_address": "c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2",
      "quote_token_address": "a0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
      "request_window": {
        "from_block": null,
        "to_block": null,
        "from_timestamp": "2025-11-11T00:00:00Z",
        "to_timestamp": "2025-11-11T01:00:00Z"
      },
      "resolved_window": {
        "from_block": null,
        "to_block": null,
        "from_timestamp": "2025-11-11T00:00:00Z",
        "to_timestamp": "2025-11-11T01:00:00Z"
      },
      "filters": {
        "exchange_ids": [1, 2],
        "pool_uids": null,
        "bucket_seconds": 60,
        "dense": false
      }
    },
    "data": [
      {
        "pool_uid": "88e6a0c2ddd26feeb64f039a2c41296fcb3f5640000000000000000000000000",
        "exchange_id": 1,
        "type_id": 201,
        "bucket_start": "2025-11-11T00:00:00.000Z",
        "bucket_end": "2025-11-11T00:01:00.000Z",
        "bucket_seconds": 60,
        "open": "3010.112233445566778899",
        "high": "3033.998877665544332211",
        "low": "3008.001122334455667788",
        "close": "3025.219821481234567890",
        "volume_base_raw": "420000000000000000000",
        "volume_base": "420.000000000000000000",
        "volume_quote_raw": "1269000000000",
        "volume_quote": "1269000.000000000000000000",
        "trades_count": 128,
        "block_bucket_first_block_number": null,
        "block_bucket_last_block_number": null,
        "block_bucket_first_block_timestamp": null,
        "block_bucket_last_block_timestamp": null,
        "block_bucket_block_count": null,
        "_tracing_id": "0404000000000000000000000000000000000001",
        "_parent_tracing_ids": null,
        "_created_at": "2025-11-11T01:00:05.000Z",
        "_updated_at": "2025-11-11T01:00:05.000Z"
      }
    ],
    "cursor": null,
    "page_count": 1
  }
  ```

  ```json 400 theme={null}
  {
    "error": {
      "code": "BAD_REQUEST",
      "http_status": 400,
      "message": "The request contains invalid or missing parameters.",
      "hint": "Validate all required parameters against the endpoint specification before retrying.",
      "severity": "error",
      "retryable": false,
      "details": {
        "invalid_parameters": [
          {
            "name": "chain_id",
            "location": "query",
            "reason": "missing",
            "expected": "positive integer, e.g. 1"
          },
          {
            "name": "from_timestamp",
            "location": "query",
            "reason": "invalid_format",
            "expected": "ISO-8601 UTC timestamp, e.g. 2025-11-11T00:00:00Z"
          }
        ]
      },
      "docs_url": "https://docs.blockdb.io/api-reference/overview/home"
    }
  }
  ```

  ```json 401 theme={null}
  {
    "error": {
      "code": "UNAUTHORIZED",
      "http_status": 401,
      "message": "Invalid or missing API key.",
      "hint": "Ensure you send 'Authorization: Bearer <API_KEY>' in every request to this endpoint.",
      "severity": "error",
      "retryable": false,
      "details": {
        "auth_scheme": "bearer",
        "expected_header": "Authorization: Bearer <API_KEY>",
        "provided_header": "Authorization: <REDACTED_OR_MISSING>",
        "token_status": "invalid_or_missing",
        "recommendation": "Regenerate the API key if you suspect it is expired or compromised."
      },
      "docs_url": "https://docs.blockdb.io/api-reference/overview/authorization"
    }
  }
  ```

  ```json 403 theme={null}
  {
    "error": {
      "code": "FORBIDDEN",
      "http_status": 403,
      "message": "Your API key does not have permission to access this endpoint.",
      "hint": "Upgrade your subscription tier or request additional access.",
      "severity": "warning",
      "retryable": false,
      "details": {
        "required_plan": "production",
        "your_plan": null,
        "contact": "support@blockdb.io",
        "recommendation": "Contact BlockDB Support Team via email support@blockdb.io."
      },
      "docs_url": "https://docs.blockdb.io/api-reference/overview/error-codes"
    }
  }
  ```

  ```json 404 theme={null}
  {
    "error": {
      "code": "NOT_FOUND",
      "http_status": 404,
      "message": "The requested resource does not exist.",
      "hint": "Verify the API endpoint",
      "severity": "warning",
      "retryable": false,
      "docs_url": "https://docs.blockdb.io/api-reference/overview/error-codes"
    }
  }
  ```

  ```json 413 theme={null}
  {
    "error": {
      "code": "PAYLOAD_TOO_LARGE",
      "http_status": 413,
      "message": "The requested response exceeds the maximum allowed size of 10 MB.",
      "hint": "Reduce the limit, narrow the block or time window, or apply additional filters before retrying.",
      "details": {
        "max_allowed_bytes": 10485760,
        "estimated_response_bytes": 15360000,
        "recommended_actions": [
          "Decrease the 'limit' parameter value",
          "Shorten the block range or time window",
          "Filter by fewer pools or exchanges"
        ]
      },
      "docs_url": "https://docs.blockdb.io/api-reference/overview/pagination-and-limits"
    }
  }
  ```

  ```json 422 theme={null}
  {
    "error": {
      "code": "CHAIN_NOT_SUPPORTED",
      "http_status": 422,
      "message": "chain_id=137 is not supported.",
      "hint": "Use a supported chain_id. Consult the documentation for the list of available chains.",
      "severity": "error",
      "retryable": false,
      "docs_url": "https://docs.blockdb.io/api-reference/overview/error-codes"
    }
  }
  ```

  ```json 429 theme={null}
  {
    "error": {
      "code": "RATE_LIMIT_EXCEEDED",
      "http_status": 429,
      "message": "You have exceeded the allowed request rate.",
      "hint": "Introduce client-side throttling or exponential backoff and respect the retry_after_seconds value.",
      "details": {
        "limit_rps": 1000, # configured rate limit
        "current_estimated_rps": 73,
        "retry_after_seconds": 2,
        "limit_scope": "api_key",
        "limit_window_seconds": 1
      },
      "docs_url": "https://docs.blockdb.io/api-reference/overview/rate-limiting"
    }
  }
  ```

  ```json 500 theme={null}
  {
    "error": {
      "code": "INTERNAL_SERVER_ERROR",
      "http_status": 500,
      "message": "An unexpected server error occurred.",
      "hint": "This error is not caused by your request. You may retry after a short delay.",
      "severity": "critical",
      "retryable": true,
      "details": {
        "incident_id": "INC-2025-11-11-123456",
        "temporary_issue": true,
        "expected_recovery_seconds": 5
      },
      "docs_url": "https://docs.blockdb.io/api-reference/overview/error-codes"
    }
  }
  ```

  ```json 503 theme={null}
  {
    "error": {
      "code": "SERVICE_UNAVAILABLE",
      "http_status": 503,
      "message": "The service is temporarily unable to handle the request.",
      "hint": "The database connection pool is briefly saturated. Retry after a short delay.",
      "severity": "warning",
      "retryable": true,
      "details": null,
      "docs_url": "https://docs.blockdb.io/api-reference/overview/error-codes"
    }
  }
  ```
</ResponseExample>