curl -X POST "https://api.blockdb.io/v1/evm/raw/transactions" \
  -H "Authorization: Bearer $BLOCKDB_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
  "chain_id": 1,
  "from_block": 12345678,
  "to_block": 12345999,
  "from_timestamp": "2025-10-29T00:00:00Z",
  "to_timestamp": "2025-11-11T00:00:00Z",
  "block_numbers": [
    12345678,
    12345679
  ],
  "tx_hashes": [
    "7b5c0972efb6a0b5be4a4d4a0de5d1abd922478a53f32b2c717a800c862ba9e0"
  ],
  "from_addresses": [
    "0000000000000000000000000000000000000000"
  ],
  "to_addresses": [
    "0000000000000000000000000000000000000001"
  ],
  "created_contract_addresses": [
    "0000000000000000000000000000000000000002"
  ],
  "status_success": true,
  "tx_types": [
    0,
    1,
    2
  ],
  "limit": 200,
  "cursor": 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,\"from_block\":12345678,\"to_block\":12345999,\"from_timestamp\":\"2025-10-29T00:00:00Z\",\"to_timestamp\":\"2025-11-11T00:00:00Z\",\"block_numbers\":[12345678,12345679],\"tx_hashes\":[\"7b5c0972efb6a0b5be4a4d4a0de5d1abd922478a53f32b2c717a800c862ba9e0\"],\"from_addresses\":[\"0000000000000000000000000000000000000000\"],\"to_addresses\":[\"0000000000000000000000000000000000000001\"],\"created_contract_addresses\":[\"0000000000000000000000000000000000000002\"],\"status_success\":true,\"tx_types\":[0,1,2],\"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/raw/transactions");
    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;
}

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,\"from_block\":12345678,\"to_block\":12345999,\"from_timestamp\":\"2025-10-29T00:00:00Z\",\"to_timestamp\":\"2025-11-11T00:00:00Z\",\"block_numbers\":[12345678,12345679],\"tx_hashes\":[\"7b5c0972efb6a0b5be4a4d4a0de5d1abd922478a53f32b2c717a800c862ba9e0\"],\"from_addresses\":[\"0000000000000000000000000000000000000000\"],\"to_addresses\":[\"0000000000000000000000000000000000000001\"],\"created_contract_addresses\":[\"0000000000000000000000000000000000000002\"],\"status_success\":true,\"tx_types\":[0,1,2],\"limit\":200,\"cursor\":null}",
            Encoding.UTF8,
            "application/json"
        );

        var response = await client.PostAsync("https://api.blockdb.io/v1/evm/raw/transactions", payload);
        response.EnsureSuccessStatusCode();

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

import os
import requests

response = requests.post(
    "https://api.blockdb.io/v1/evm/raw/transactions",
    headers={
        "Authorization": f"Bearer {os.getenv('BLOCKDB_API_KEY')}",
        "Content-Type": "application/json"
    },
    json={'block_numbers': [12345678, 12345679],
 'chain_id': 1,
 'created_contract_addresses': ['0000000000000000000000000000000000000002'],
 'from_addresses': ['0000000000000000000000000000000000000000'],
 'from_block': 12345678,
 'from_timestamp': '2025-10-29T00:00:00Z',
 'status_success': True,
 'to_addresses': ['0000000000000000000000000000000000000001'],
 'to_block': 12345999,
 'to_timestamp': '2025-11-11T00:00:00Z',
 'tx_hashes': ['7b5c0972efb6a0b5be4a4d4a0de5d1abd922478a53f32b2c717a800c862ba9e0'],
 'tx_types': [0, 1, 2],
 'limit': 200,
 'cursor': None}
)

data = response.json()
print(data)

const response = await fetch("https://api.blockdb.io/v1/evm/raw/transactions", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.BLOCKDB_API_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
  "chain_id": 1,
  "from_block": 12345678,
  "to_block": 12345999,
  "from_timestamp": "2025-10-29T00:00:00Z",
  "to_timestamp": "2025-11-11T00:00:00Z",
  "block_numbers": [
    12345678,
    12345679
  ],
  "tx_hashes": [
    "7b5c0972efb6a0b5be4a4d4a0de5d1abd922478a53f32b2c717a800c862ba9e0"
  ],
  "from_addresses": [
    "0000000000000000000000000000000000000000"
  ],
  "to_addresses": [
    "0000000000000000000000000000000000000001"
  ],
  "created_contract_addresses": [
    "0000000000000000000000000000000000000002"
  ],
  "status_success": true,
  "tx_types": [
    0,
    1,
    2
  ],
  "limit": 200,
  "cursor": null
})
});

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

package main

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

func main() {
    payload := strings.NewReader(`{
  "chain_id": 1,
  "from_block": 12345678,
  "to_block": 12345999,
  "from_timestamp": "2025-10-29T00:00:00Z",
  "to_timestamp": "2025-11-11T00:00:00Z",
  "block_numbers": [
    12345678,
    12345679
  ],
  "tx_hashes": [
    "7b5c0972efb6a0b5be4a4d4a0de5d1abd922478a53f32b2c717a800c862ba9e0"
  ],
  "from_addresses": [
    "0000000000000000000000000000000000000000"
  ],
  "to_addresses": [
    "0000000000000000000000000000000000000001"
  ],
  "created_contract_addresses": [
    "0000000000000000000000000000000000000002"
  ],
  "status_success": true,
  "tx_types": [
    0,
    1,
    2
  ],
  "limit": 200,
  "cursor": null
}`)

    req, _ := http.NewRequest("POST", "https://api.blockdb.io/v1/evm/raw/transactions", 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
}

{
  "meta": {
    "chain_id": 1,
    "request_window": {
      "from_block": 12345678,
      "to_block": 12345999,
      "from_timestamp": "2025-10-29T00:00:00Z",
      "to_timestamp": "2025-11-11T00:00:00Z"
    },
    "resolved_window": {
      "from_block": 12345678,
      "to_block": 12345999,
      "from_timestamp": "2025-10-29T00:00:00Z",
      "to_timestamp": "2025-11-11T00:00:00Z"
    },
    "filters": {
      "block_numbers": [
        12345678,
        12345679
      ],
      "tx_hashes": [
        "7b5c0972efb6a0b5be4a4d4a0de5d1abd922478a53f32b2c717a800c862ba9e0"
      ],
      "from_addresses": [
        "0000000000000000000000000000000000000000"
      ],
      "to_addresses": [
        "0000000000000000000000000000000000000001"
      ],
      "created_contract_addresses": [
        "0000000000000000000000000000000000000002"
      ],
      "status_success": true,
      "tx_types": [
        0,
        1,
        2
      ]
    }
  },
  "data": [
    {
      "block_number": 12345678,
      "block_time": "2025-11-11T18:42:15.123Z",
      "tx_hash": "7b5c0972efb6a0b5be4a4d4a0de5d1abd922478a53f32b2c717a800c862ba9e0",
      "tx_index": 4,
      "from_address": "0000000000000000000000000000000000000000",
      "to_address": "0000000000000000000000000000000000000001",
      "created_contract_address": null,
      "gas_used": "21000",
      "effective_gas_price_wei": "1234567890123456789",
      "status_success": true,
      "root": null,
      "tx_type": 2,
      "trace_failed": false,
      "value_wei": "0",
      "input": "a9059cbb000000000000000000000000000000000000000100000bb875f007400000000000100000bb875f007400000000000000000000000000000000000000000000000003e8",
      "nonce": 7,
      "gas_limit": 21000,
      "gas_price_wei": "1234567890",
      "max_fee_per_gas_wei": "2000000000",
      "max_priority_fee_per_gas_wei": "1000000000",
      "_tracing_id": "010200000000000000000000000000000000",
      "_created_at": "2025-11-11T18:42:15.123Z",
      "_updated_at": "2025-11-11T18:42:15.123Z"
    }
  ],
  "cursor": null,
  "page_count": 1
}

{
  "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"
  }
}

{
  "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"
  }
}

{
  "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"
  }
}

{
  "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"
  }
}

{
  "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"
  }
}

{
  "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"
  }
}

{
  "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"
  }
}

{
  "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"
  }
}

{
  "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"
  }
}