# Быстрый старт

> Source: https://docs.blockvectra.com/ru/quickstart/

Разработчики и AI Agent могут протестировать публичный RPC без ключа, а затем создать ключ для продолжения работы.

## 1. Получение высоты блока без ключа

Вызовите публичный эндпоинт JSON-RPC для примера сети `robinhood_mainnet` без создания аккаунта и передачи API key:

```bash
curl -s "https://api.blockvectra.com/v1/robinhood_mainnet/public" \
  -H 'Content-Type: application/json' \
  -d '{"jsonrpc":"2.0","id":1,"method":"eth_blockNumber","params":[]}'
```

Значение `id: 1` в ответе соответствует этому запросу; `result` — шестнадцатеричная высота блока, которая может меняться между вызовами. Если ответ содержит `error`, проверьте его код и причину. См. [бесплатные публичные эндпоинты RPC](https://blockvectra.com/ru/free/#public-rpc), где перечислены публичные методы, диапазоны истории и лимиты на IP.

## 2. Создание API key

Перейдите в [консоль](https://console.blockvectra.com/login/?next=%2Fkeys%2F), войдите с помощью GitHub, Google или кошелька Ethereum (аккаунт создается при первом входе) и создайте API key. Секретный ключ отображается только один раз: сохраните его в надежном месте и задайте в переменной окружения `BLOCKVECTRA_API_KEY`. Не используйте его в клиентском коде браузера. Новые аккаунты получают 30,000,000 CU при регистрации — банковская карта не требуется.

> **У вас еще нет API key?**
>
> Если у вас есть кошелек Ethereum: следуйте [руководству по программной регистрации](https://docs.blockvectra.com/ru/guides/programmatic-signup/), чтобы зарегистрироваться и создать API key с помощью подписи кошелька Ethereum без браузера. Если у вас нет кошелька: попросите пользователя войти на [console.blockvectra.com](https://console.blockvectra.com/login/?next=%2Fkeys%2F), создать ключ и задать его в переменной окружения `BLOCKVECTRA_API_KEY`. Не просите пользователя вставлять ключ в чат.


## 3. Отправка первого аутентифицированного запроса

Запросите высоту блока той же сети с заголовком `x-api-key`. URL заканчивается названием сети, без завершающего слэша:

```bash
: "${BLOCKVECTRA_API_KEY:?Set BLOCKVECTRA_API_KEY first}"

curl -s "https://api.blockvectra.com/v1/robinhood_mainnet" \
  -H 'Content-Type: application/json' \
  -H "x-api-key: $BLOCKVECTRA_API_KEY" \
  -d '{"jsonrpc":"2.0","id":1,"method":"eth_blockNumber","params":[]}'
```

`result` снова содержит шестнадцатеричную высоту блока. Этот запрос расходует CU; см. [справочник JSON-RPC](https://docs.blockvectra.com/ru/api/json-rpc/) для ознакомления с весами методов и кодами ошибок, а также [Цены](https://blockvectra.com/ru/pricing/) с актуальными тарифами. Новый ключ вступает в силу примерно через 5 секунд; если вы получаете `invalid_api_key`, подождите немного и повторите попытку. При возникновении других сбоев см. раздел [Распространенные ошибки](#common-errors) ниже.

## 4. Переход к бизнес-задачам

* [Запрос ончейн-активности токенизированных акций в Robinhood Chain](https://docs.blockvectra.com/ru/guides/stocks/)
* [Пакетная выгрузка логов HyperEVM по частям](https://docs.blockvectra.com/ru/guides/hyperevm-backfill/)
* [Получение активности кошельков и переводов токенов через вебхуки](https://docs.blockvectra.com/ru/guides/webhook-push/)

## Справочник

### API keys и баланс

Готовый стартовый шаблон: [blockvectra/agent-quickstart](https://github.com/blockvectra/agent-quickstart)

Каждый ключ выглядит как префикс `rgw_`, за которым следуют 64 шестнадцатеричных символа, например
`rgw_1f2e...` (сокращено). Храните его в секрете — любой, у кого есть ключ, может расходовать ваш баланс.

> При недостаточном балансе сервер возвращает HTTP 402 (код ошибки JSON-RPC `-32020`; Data API `error.code` `insufficient_balance`). Перейдите на [страницу биллинга](https://console.blockvectra.com/billing/) в консоли, чтобы проверить баланс и способы пополнения.


### Тестирование без ключа

Вы можете сразу вызывать публичную конечную точку JSON-RPC без создания аккаунта или указания API key. Конечная точка в примере ниже ограничена по частоте запросов с одного IP (3 запр/с, burst 20, макс. размер пакета 10). Запросы, превышающие лимиты, возвращают HTTP 429 с причиной `public_rate_limit` или `public_pool_busy` (с заголовком `Retry-After`); неподдерживаемые методы возвращают ошибку JSON-RPC `-32601` (`method_not_public`).

```bash
# Прямая публичная конечная точка:
curl -s "https://api.blockvectra.com/v1/robinhood_mainnet/public" \
  -H 'Content-Type: application/json' \
  -d '{"jsonrpc":"2.0","id":1,"method":"eth_blockNumber","params":[]}'

# Или с шаблоном резервного API key (по умолчанию публичный, если BLOCKVECTRA_API_KEY не задан):
curl -s "https://api.blockvectra.com/v1/robinhood_mainnet/${BLOCKVECTRA_API_KEY:-public}" \
  -H 'Content-Type: application/json' \
  -d '{"jsonrpc":"2.0","id":1,"method":"eth_blockNumber","params":[]}'
```

#### Публичные конечные точки по сетям

- Arbitrum One: https://api.blockvectra.com/v1/arb_mainnet/public — Чтение и отправка подписанных транзакций (eth_sendRawTransaction)
- Base: https://api.blockvectra.com/v1/base_mainnet/public — Чтение и отправка подписанных транзакций (eth_sendRawTransaction)
- BNB Smart Chain: https://api.blockvectra.com/v1/bsc_mainnet/public — Чтение и отправка подписанных транзакций (eth_sendRawTransaction)
- Ethereum: https://api.blockvectra.com/v1/eth_mainnet/public — Чтение и отправка подписанных транзакций (eth_sendRawTransaction)
- Ethereum Sepolia: https://api.blockvectra.com/v1/eth_sepolia/public — Чтение и отправка подписанных транзакций (eth_sendRawTransaction)
- HyperEVM: https://api.blockvectra.com/v1/hyperevm_mainnet/public — Только для чтения
- Polygon: https://api.blockvectra.com/v1/polygon_mainnet/public — Чтение и отправка подписанных транзакций (eth_sendRawTransaction)
- Robinhood Chain: https://api.blockvectra.com/v1/robinhood_mainnet/public — Чтение и отправка подписанных транзакций (eth_sendRawTransaction)
- Robinhood Chain Testnet: https://api.blockvectra.com/v1/robinhood_testnet/public — Чтение и отправка подписанных транзакций (eth_sendRawTransaction)

Следующие два публичных эндпоинта метаданных показывают статус сервиса и конфигурацию каждой сети; они не требуют API key и не тарифицируются.

### Проверка статуса сервиса и состояния сетей

```bash
curl https://api.blockvectra.com/v1/status
```

Возвращает временную метку проверки `checked_at`, рабочий статус сервиса `gateway.status`, а также прогресс синхронизации узла `sync`, высоту головного блока и задержку `head` для каждой поддерживаемой сети:

```json
{
  "checked_at": "2026-10-03T13:30:47Z",
  "gateway": {
    "status": "ok"
  },
  "chains": [
    {
      "chain": "bsc_mainnet",
      "name": "BNB Smart Chain",
      "chain_id": 56,
      "jsonrpc": true,
      "data": true,
      "data_features": [
        "blocks",
        "transactions",
        "address_transactions",
        "transfers",
        "token_metadata",
        "freshness"
      ],
      "data_status": "ok",
      "data_head_block": 125492675,
      "data_head_age_seconds": 3,
      "status": "ok",
      "sync": {
        "stage": "synced",
        "node_block": 125492676,
        "target_block": null
      },
      "head": {
        "block": 125492676,
        "time": "2026-10-03T13:30:45Z",
        "lag_seconds": 2
      }
    }
  ]
}
```

### Запрос поддерживаемых сетей и политик методов

```bash
curl https://api.blockvectra.com/v1/chains
```

Возвращает `chain_id` каждой поддерживаемой сети, флаги возможностей для JSON-RPC, Data API и WebSocket, политики разрешенных и запрещенных методов (`methods.allow` и `methods.deny`), лимит диапазона блоков логов в одном запросе `max_logs_block_range` и окно исторического состояния `state_window_blocks`:

```json
{
  "chains": [
    {
      "chain": "bsc_mainnet",
      "name": "BNB Smart Chain",
      "chain_id": 56,
      "jsonrpc": true,
      "data": true,
      "ws": false,
      "subscriptions": [],
      "methods": {
        "allow": [
          "eth_blockNumber",
          "eth_call",
          "eth_chainId",
          "eth_getLogs"
        ],
        "deny": [
          "eth_newFilter",
          "eth_subscribe",
          "eth_unsubscribe"
        ]
      },
      "max_logs_block_range": 1000,
      "state_window_blocks": 990000,
      "info": {}
    }
  ]
}
```

### Выбор сети

Каждый эндпоинт BlockVectra привязан к определенной сети: запросы JSON-RPC содержат имя сети `{chain}` в пути URL, а запросы Data API начинаются с него. Список доступных на данный момент сетей и их идентификаторов см. в разделе [Поддерживаемые сети](https://docs.blockvectra.com/ru/chains/).

| Сеть | {chain} | Chain ID | Tracing | Публичный эндпоинт | WebSocket | Data API | Число методов с API key | Webhook-уведомления | Отправка транзакций | Отправка транзакций (публичная конечная точка без key) | Окно истории состояния | Максимальный диапазон блоков для eth_getLogs | Наборы данных Data API | Связанные тестовые сети | Связанные руководства |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| [arb_mainnet: RPC и Data API](https://blockvectra.com/ru/chains/arb_mainnet/) | arb_mainnet | 42161 | ✓ | `https://api.blockvectra.com/v1/arb_mainnet/public` | Не поддерживается | Доступно | 43 | [Поддерживается · Подтверждения 1–1 (по умолчанию 1)](https://blockvectra.com/ru/webhooks/), [Руководство по Webhook-уведомлениям](https://docs.blockvectra.com/en/guides/webhook-push/) | Поддерживается | Поддерживается | Историческое состояние за последние 6,000 блоков | 1,000 блоков | Блоки, Транзакции, Транзакции адреса, Переводы, Метаданные токенов, Свежесть данных | Неизвестно | Неизвестно |
| [base_mainnet: RPC и Data API](https://blockvectra.com/ru/chains/base_mainnet/) | base_mainnet | 8453 | — | `https://api.blockvectra.com/v1/base_mainnet/public` | Не поддерживается | Доступно | 39 | [Поддерживается · Подтверждения 1–1 (по умолчанию 1)](https://blockvectra.com/ru/webhooks/), [Руководство по Webhook-уведомлениям](https://docs.blockvectra.com/en/guides/webhook-push/) | Поддерживается | Поддерживается | Историческое состояние за последние 10,000 блоков | 1,000 блоков | Блоки, Транзакции, Транзакции адреса, Переводы, Метаданные токенов, Свежесть данных | Неизвестно | [Base](https://docs.blockvectra.com/en/guides/base/) |
| [bsc_mainnet: RPC и Data API](https://blockvectra.com/ru/chains/bsc_mainnet/) | bsc_mainnet | 56 | — | `https://api.blockvectra.com/v1/bsc_mainnet/public` | Не поддерживается | Доступно | 25 | [Поддерживается · Подтверждения 1–1 (по умолчанию 1)](https://blockvectra.com/ru/webhooks/), [Руководство по Webhook-уведомлениям](https://docs.blockvectra.com/en/guides/webhook-push/) | Поддерживается | Поддерживается | Историческое состояние за последние 100 блоков | 1,000 блоков | Блоки, Транзакции, Транзакции адреса, Переводы, Метаданные токенов, Свежесть данных | Неизвестно | Неизвестно |
| [Ethereum: RPC и Data API](https://blockvectra.com/ru/chains/eth_mainnet/) | eth_mainnet | 1 | ✓ | `https://api.blockvectra.com/v1/eth_mainnet/public` | Не поддерживается | Доступно | 38 | [Поддерживается · Подтверждения 1–1 (по умолчанию 1)](https://blockvectra.com/ru/webhooks/), [Руководство по Webhook-уведомлениям](https://docs.blockvectra.com/en/guides/webhook-push/) | Поддерживается | Поддерживается | Историческое состояние за последние 250,000 блоков | 1,000 блоков | Блоки, Транзакции, Транзакции адреса, Переводы, Метаданные токенов, Свежесть данных | Неизвестно | Неизвестно |
| [eth_sepolia: RPC и Data API](https://blockvectra.com/ru/chains/eth_sepolia/) | eth_sepolia | 11155111 | — | `https://api.blockvectra.com/v1/eth_sepolia/public` | Не поддерживается | Доступно | 29 | [Поддерживается · Подтверждения 1–1 (по умолчанию 1)](https://blockvectra.com/ru/webhooks/), [Руководство по Webhook-уведомлениям](https://docs.blockvectra.com/en/guides/webhook-push/) | Поддерживается | Поддерживается | Неизвестно | 1,000 блоков | Блоки, Транзакции, Транзакции адреса, Переводы, Метаданные токенов, Свежесть данных | Неизвестно | Неизвестно |
| [HyperEVM: RPC и Data API](https://blockvectra.com/ru/chains/hyperevm_mainnet/) | hyperevm_mainnet | 999 | — | `https://api.blockvectra.com/v1/hyperevm_mainnet/public` | Не поддерживается | Доступно | 24 | [Поддерживается · Подтверждения 1–1 (по умолчанию 1)](https://blockvectra.com/ru/webhooks/), [Руководство по Webhook-уведомлениям](https://docs.blockvectra.com/en/guides/webhook-push/) | Не поддерживается | Не поддерживается | Неизвестно | 1,000 блоков | Блоки, Транзакции, Транзакции адреса, Переводы, Метаданные токенов, Балансы, Держатели, NFT, Свежесть данных | Неизвестно | [HyperEVM backfill and polling](https://docs.blockvectra.com/en/guides/hyperevm-backfill/) |
| [polygon_mainnet: RPC и Data API](https://blockvectra.com/ru/chains/polygon_mainnet/) | polygon_mainnet | 137 | ✓ | `https://api.blockvectra.com/v1/polygon_mainnet/public` | Не поддерживается | Доступно | 43 | [Поддерживается · Подтверждения 1–1 (по умолчанию 1)](https://blockvectra.com/ru/webhooks/), [Руководство по Webhook-уведомлениям](https://docs.blockvectra.com/en/guides/webhook-push/) | Поддерживается | Поддерживается | Историческое состояние за последние 126 блоков | 1,000 блоков | Блоки, Транзакции, Транзакции адреса, Переводы, Метаданные токенов, Свежесть данных | Неизвестно | Неизвестно |
| [Robinhood Chain: RPC и Data API](https://blockvectra.com/ru/chains/robinhood_mainnet/) | robinhood_mainnet | 4663 | ✓ | `https://api.blockvectra.com/v1/robinhood_mainnet/public` | Поддерживается (newHeads, logs) | Доступно | 43 | [Поддерживается · Подтверждения 1–1 (по умолчанию 1)](https://blockvectra.com/ru/webhooks/), [Руководство по Webhook-уведомлениям](https://docs.blockvectra.com/en/guides/webhook-push/) | Поддерживается | Поддерживается | Историческое состояние за последние 900 блоков | 1,000 блоков | Блоки, Транзакции, Транзакции адреса, Переводы, Метаданные токенов, Балансы, Держатели, NFT, Свопы DEX, Цены DEX, Токенизированные акции, Трассировки, Свежесть данных | Неизвестно | [Robinhood Chain](https://docs.blockvectra.com/en/guides/robinhood-chain/), [Stock token multiplier](https://docs.blockvectra.com/en/guides/stock-token-multiplier/), [Tokenized stocks](https://docs.blockvectra.com/en/guides/stocks/) |
| [robinhood_testnet: RPC](https://blockvectra.com/ru/chains/robinhood_testnet/) | robinhood_testnet | 46630 | ✓ | `https://api.blockvectra.com/v1/robinhood_testnet/public` | Поддерживается (newHeads, logs) | Пока недоступно | 43 | [Поддерживается · Подтверждения 1–1 (по умолчанию 1)](https://blockvectra.com/ru/webhooks/), [Руководство по Webhook-уведомлениям](https://docs.blockvectra.com/en/guides/webhook-push/) | Поддерживается | Поддерживается | Историческое состояние за последние 1,023 блоков | 1,000 блоков | Не поддерживается | Неизвестно | [Testnet faucet](https://docs.blockvectra.com/en/guides/robinhood-testnet-faucet/), [Robinhood Chain Testnet starter](https://docs.blockvectra.com/en/guides/robinhood-testnet-starter/) |

## Следующие шаги с API key

### arb_mainnet

#### eth_getLogs

```bash
set -eu
MAX_LOGS_BLOCK_RANGE=1000
head=$(curl -fsS 'https://api.blockvectra.com/v1/arb_mainnet' -H "x-api-key: $BLOCKVECTRA_API_KEY" -H 'Content-Type: application/json' -d '{"jsonrpc":"2.0","id":1,"method":"eth_blockNumber","params":[]}' | python3 -c 'import json,sys; print(int(json.load(sys.stdin)["result"],16))')
from=$((head >= MAX_LOGS_BLOCK_RANGE ? head - MAX_LOGS_BLOCK_RANGE + 1 : 0))
from_hex=$(printf '0x%x' "$from")
to_hex=$(printf '0x%x' "$head")
curl -fsS 'https://api.blockvectra.com/v1/arb_mainnet' -H "x-api-key: $BLOCKVECTRA_API_KEY" -H 'Content-Type: application/json' \
  -d "{\"jsonrpc\":\"2.0\",\"id\":1,\"method\":\"eth_getLogs\",\"params\":[{\"fromBlock\":\"$from_hex\",\"toBlock\":\"$to_hex\"}]}"
```

[eth_getLogs](https://docs.blockvectra.com/en/guides/getlogs-block-range/)

#### Data API

```bash
curl -fsS 'https://api.blockvectra.com/v1/data/arb_mainnet/status/freshness' -H "x-api-key: $BLOCKVECTRA_API_KEY"
```

[Data API](https://docs.blockvectra.com/en/api/data/)

[Создать подписку Webhook](https://blockvectra.com/ru/webhooks/) · [Создать подписку Webhook](https://docs.blockvectra.com/en/guides/webhook-push/) · [Использование и CU](https://console.blockvectra.com/usage/) · [Пополнить баланс](https://console.blockvectra.com/billing/)

### base_mainnet

#### eth_getLogs

```bash
set -eu
MAX_LOGS_BLOCK_RANGE=1000
head=$(curl -fsS 'https://api.blockvectra.com/v1/base_mainnet' -H "x-api-key: $BLOCKVECTRA_API_KEY" -H 'Content-Type: application/json' -d '{"jsonrpc":"2.0","id":1,"method":"eth_blockNumber","params":[]}' | python3 -c 'import json,sys; print(int(json.load(sys.stdin)["result"],16))')
from=$((head >= MAX_LOGS_BLOCK_RANGE ? head - MAX_LOGS_BLOCK_RANGE + 1 : 0))
from_hex=$(printf '0x%x' "$from")
to_hex=$(printf '0x%x' "$head")
curl -fsS 'https://api.blockvectra.com/v1/base_mainnet' -H "x-api-key: $BLOCKVECTRA_API_KEY" -H 'Content-Type: application/json' \
  -d "{\"jsonrpc\":\"2.0\",\"id\":1,\"method\":\"eth_getLogs\",\"params\":[{\"fromBlock\":\"$from_hex\",\"toBlock\":\"$to_hex\"}]}"
```

[eth_getLogs](https://docs.blockvectra.com/en/guides/getlogs-block-range/)

#### Data API

```bash
curl -fsS 'https://api.blockvectra.com/v1/data/base_mainnet/status/freshness' -H "x-api-key: $BLOCKVECTRA_API_KEY"
```

[Data API](https://docs.blockvectra.com/en/api/data/)

[Создать подписку Webhook](https://blockvectra.com/ru/webhooks/) · [Создать подписку Webhook](https://docs.blockvectra.com/en/guides/webhook-push/) · [Использование и CU](https://console.blockvectra.com/usage/) · [Пополнить баланс](https://console.blockvectra.com/billing/)

### bsc_mainnet

#### eth_getLogs

```bash
set -eu
MAX_LOGS_BLOCK_RANGE=1000
head=$(curl -fsS 'https://api.blockvectra.com/v1/bsc_mainnet' -H "x-api-key: $BLOCKVECTRA_API_KEY" -H 'Content-Type: application/json' -d '{"jsonrpc":"2.0","id":1,"method":"eth_blockNumber","params":[]}' | python3 -c 'import json,sys; print(int(json.load(sys.stdin)["result"],16))')
from=$((head >= MAX_LOGS_BLOCK_RANGE ? head - MAX_LOGS_BLOCK_RANGE + 1 : 0))
from_hex=$(printf '0x%x' "$from")
to_hex=$(printf '0x%x' "$head")
curl -fsS 'https://api.blockvectra.com/v1/bsc_mainnet' -H "x-api-key: $BLOCKVECTRA_API_KEY" -H 'Content-Type: application/json' \
  -d "{\"jsonrpc\":\"2.0\",\"id\":1,\"method\":\"eth_getLogs\",\"params\":[{\"fromBlock\":\"$from_hex\",\"toBlock\":\"$to_hex\"}]}"
```

[eth_getLogs](https://docs.blockvectra.com/en/guides/getlogs-block-range/)

#### Data API

```bash
curl -fsS 'https://api.blockvectra.com/v1/data/bsc_mainnet/status/freshness' -H "x-api-key: $BLOCKVECTRA_API_KEY"
```

[Data API](https://docs.blockvectra.com/en/api/data/)

[Создать подписку Webhook](https://blockvectra.com/ru/webhooks/) · [Создать подписку Webhook](https://docs.blockvectra.com/en/guides/webhook-push/) · [Использование и CU](https://console.blockvectra.com/usage/) · [Пополнить баланс](https://console.blockvectra.com/billing/)

### Ethereum

#### eth_getLogs

```bash
set -eu
MAX_LOGS_BLOCK_RANGE=1000
head=$(curl -fsS 'https://api.blockvectra.com/v1/eth_mainnet' -H "x-api-key: $BLOCKVECTRA_API_KEY" -H 'Content-Type: application/json' -d '{"jsonrpc":"2.0","id":1,"method":"eth_blockNumber","params":[]}' | python3 -c 'import json,sys; print(int(json.load(sys.stdin)["result"],16))')
from=$((head >= MAX_LOGS_BLOCK_RANGE ? head - MAX_LOGS_BLOCK_RANGE + 1 : 0))
from_hex=$(printf '0x%x' "$from")
to_hex=$(printf '0x%x' "$head")
curl -fsS 'https://api.blockvectra.com/v1/eth_mainnet' -H "x-api-key: $BLOCKVECTRA_API_KEY" -H 'Content-Type: application/json' \
  -d "{\"jsonrpc\":\"2.0\",\"id\":1,\"method\":\"eth_getLogs\",\"params\":[{\"fromBlock\":\"$from_hex\",\"toBlock\":\"$to_hex\"}]}"
```

[eth_getLogs](https://docs.blockvectra.com/en/guides/getlogs-block-range/)

#### Data API

```bash
curl -fsS 'https://api.blockvectra.com/v1/data/eth_mainnet/status/freshness' -H "x-api-key: $BLOCKVECTRA_API_KEY"
```

[Data API](https://docs.blockvectra.com/en/api/data/)

[Создать подписку Webhook](https://blockvectra.com/ru/webhooks/) · [Создать подписку Webhook](https://docs.blockvectra.com/en/guides/webhook-push/) · [Использование и CU](https://console.blockvectra.com/usage/) · [Пополнить баланс](https://console.blockvectra.com/billing/)

### eth_sepolia

#### eth_getLogs

```bash
set -eu
MAX_LOGS_BLOCK_RANGE=1000
head=$(curl -fsS 'https://api.blockvectra.com/v1/eth_sepolia' -H "x-api-key: $BLOCKVECTRA_API_KEY" -H 'Content-Type: application/json' -d '{"jsonrpc":"2.0","id":1,"method":"eth_blockNumber","params":[]}' | python3 -c 'import json,sys; print(int(json.load(sys.stdin)["result"],16))')
from=$((head >= MAX_LOGS_BLOCK_RANGE ? head - MAX_LOGS_BLOCK_RANGE + 1 : 0))
from_hex=$(printf '0x%x' "$from")
to_hex=$(printf '0x%x' "$head")
curl -fsS 'https://api.blockvectra.com/v1/eth_sepolia' -H "x-api-key: $BLOCKVECTRA_API_KEY" -H 'Content-Type: application/json' \
  -d "{\"jsonrpc\":\"2.0\",\"id\":1,\"method\":\"eth_getLogs\",\"params\":[{\"fromBlock\":\"$from_hex\",\"toBlock\":\"$to_hex\"}]}"
```

[eth_getLogs](https://docs.blockvectra.com/en/guides/getlogs-block-range/)

#### Data API

```bash
curl -fsS 'https://api.blockvectra.com/v1/data/eth_sepolia/status/freshness' -H "x-api-key: $BLOCKVECTRA_API_KEY"
```

[Data API](https://docs.blockvectra.com/en/api/data/)

[Создать подписку Webhook](https://blockvectra.com/ru/webhooks/) · [Создать подписку Webhook](https://docs.blockvectra.com/en/guides/webhook-push/) · [Использование и CU](https://console.blockvectra.com/usage/) · [Пополнить баланс](https://console.blockvectra.com/billing/)

### HyperEVM

#### eth_getLogs

```bash
set -eu
MAX_LOGS_BLOCK_RANGE=1000
head=$(curl -fsS 'https://api.blockvectra.com/v1/hyperevm_mainnet' -H "x-api-key: $BLOCKVECTRA_API_KEY" -H 'Content-Type: application/json' -d '{"jsonrpc":"2.0","id":1,"method":"eth_blockNumber","params":[]}' | python3 -c 'import json,sys; print(int(json.load(sys.stdin)["result"],16))')
from=$((head >= MAX_LOGS_BLOCK_RANGE ? head - MAX_LOGS_BLOCK_RANGE + 1 : 0))
from_hex=$(printf '0x%x' "$from")
to_hex=$(printf '0x%x' "$head")
curl -fsS 'https://api.blockvectra.com/v1/hyperevm_mainnet' -H "x-api-key: $BLOCKVECTRA_API_KEY" -H 'Content-Type: application/json' \
  -d "{\"jsonrpc\":\"2.0\",\"id\":1,\"method\":\"eth_getLogs\",\"params\":[{\"fromBlock\":\"$from_hex\",\"toBlock\":\"$to_hex\"}]}"
```

[eth_getLogs](https://docs.blockvectra.com/en/guides/getlogs-block-range/)

#### Data API

```bash
curl -fsS 'https://api.blockvectra.com/v1/data/hyperevm_mainnet/status/freshness' -H "x-api-key: $BLOCKVECTRA_API_KEY"
```

[Data API](https://docs.blockvectra.com/en/api/data/)

[Создать подписку Webhook](https://blockvectra.com/ru/webhooks/) · [Создать подписку Webhook](https://docs.blockvectra.com/en/guides/webhook-push/) · [Использование и CU](https://console.blockvectra.com/usage/) · [Пополнить баланс](https://console.blockvectra.com/billing/)

### polygon_mainnet

#### eth_getLogs

```bash
set -eu
MAX_LOGS_BLOCK_RANGE=1000
head=$(curl -fsS 'https://api.blockvectra.com/v1/polygon_mainnet' -H "x-api-key: $BLOCKVECTRA_API_KEY" -H 'Content-Type: application/json' -d '{"jsonrpc":"2.0","id":1,"method":"eth_blockNumber","params":[]}' | python3 -c 'import json,sys; print(int(json.load(sys.stdin)["result"],16))')
from=$((head >= MAX_LOGS_BLOCK_RANGE ? head - MAX_LOGS_BLOCK_RANGE + 1 : 0))
from_hex=$(printf '0x%x' "$from")
to_hex=$(printf '0x%x' "$head")
curl -fsS 'https://api.blockvectra.com/v1/polygon_mainnet' -H "x-api-key: $BLOCKVECTRA_API_KEY" -H 'Content-Type: application/json' \
  -d "{\"jsonrpc\":\"2.0\",\"id\":1,\"method\":\"eth_getLogs\",\"params\":[{\"fromBlock\":\"$from_hex\",\"toBlock\":\"$to_hex\"}]}"
```

[eth_getLogs](https://docs.blockvectra.com/en/guides/getlogs-block-range/)

#### Data API

```bash
curl -fsS 'https://api.blockvectra.com/v1/data/polygon_mainnet/status/freshness' -H "x-api-key: $BLOCKVECTRA_API_KEY"
```

[Data API](https://docs.blockvectra.com/en/api/data/)

[Создать подписку Webhook](https://blockvectra.com/ru/webhooks/) · [Создать подписку Webhook](https://docs.blockvectra.com/en/guides/webhook-push/) · [Использование и CU](https://console.blockvectra.com/usage/) · [Пополнить баланс](https://console.blockvectra.com/billing/)

### Robinhood Chain

#### eth_getLogs

```bash
set -eu
MAX_LOGS_BLOCK_RANGE=1000
head=$(curl -fsS 'https://api.blockvectra.com/v1/robinhood_mainnet' -H "x-api-key: $BLOCKVECTRA_API_KEY" -H 'Content-Type: application/json' -d '{"jsonrpc":"2.0","id":1,"method":"eth_blockNumber","params":[]}' | python3 -c 'import json,sys; print(int(json.load(sys.stdin)["result"],16))')
from=$((head >= MAX_LOGS_BLOCK_RANGE ? head - MAX_LOGS_BLOCK_RANGE + 1 : 0))
from_hex=$(printf '0x%x' "$from")
to_hex=$(printf '0x%x' "$head")
curl -fsS 'https://api.blockvectra.com/v1/robinhood_mainnet' -H "x-api-key: $BLOCKVECTRA_API_KEY" -H 'Content-Type: application/json' \
  -d "{\"jsonrpc\":\"2.0\",\"id\":1,\"method\":\"eth_getLogs\",\"params\":[{\"fromBlock\":\"$from_hex\",\"toBlock\":\"$to_hex\"}]}"
```

[eth_getLogs](https://docs.blockvectra.com/en/guides/getlogs-block-range/)

#### Data API

```bash
curl -fsS 'https://api.blockvectra.com/v1/data/robinhood_mainnet/status/freshness' -H "x-api-key: $BLOCKVECTRA_API_KEY"
```

[Data API](https://docs.blockvectra.com/en/api/data/)

#### WebSocket

```bash
echo '{"jsonrpc":"2.0","id":1,"method":"eth_subscribe","params":["newHeads"]}' | websocat --no-close -H="x-api-key: $BLOCKVECTRA_API_KEY" 'wss://api.blockvectra.com/v1/robinhood_mainnet'
```

[WebSocket](https://docs.blockvectra.com/en/guides/websocket-subscriptions/)

[Создать подписку Webhook](https://blockvectra.com/ru/webhooks/) · [Создать подписку Webhook](https://docs.blockvectra.com/en/guides/webhook-push/) · [Использование и CU](https://console.blockvectra.com/usage/) · [Пополнить баланс](https://console.blockvectra.com/billing/)

### robinhood_testnet

#### eth_getLogs

```bash
set -eu
MAX_LOGS_BLOCK_RANGE=1000
head=$(curl -fsS 'https://api.blockvectra.com/v1/robinhood_testnet' -H "x-api-key: $BLOCKVECTRA_API_KEY" -H 'Content-Type: application/json' -d '{"jsonrpc":"2.0","id":1,"method":"eth_blockNumber","params":[]}' | python3 -c 'import json,sys; print(int(json.load(sys.stdin)["result"],16))')
from=$((head >= MAX_LOGS_BLOCK_RANGE ? head - MAX_LOGS_BLOCK_RANGE + 1 : 0))
from_hex=$(printf '0x%x' "$from")
to_hex=$(printf '0x%x' "$head")
curl -fsS 'https://api.blockvectra.com/v1/robinhood_testnet' -H "x-api-key: $BLOCKVECTRA_API_KEY" -H 'Content-Type: application/json' \
  -d "{\"jsonrpc\":\"2.0\",\"id\":1,\"method\":\"eth_getLogs\",\"params\":[{\"fromBlock\":\"$from_hex\",\"toBlock\":\"$to_hex\"}]}"
```

[eth_getLogs](https://docs.blockvectra.com/en/guides/getlogs-block-range/)

#### WebSocket

```bash
echo '{"jsonrpc":"2.0","id":1,"method":"eth_subscribe","params":["newHeads"]}' | websocat --no-close -H="x-api-key: $BLOCKVECTRA_API_KEY" 'wss://api.blockvectra.com/v1/robinhood_testnet'
```

[WebSocket](https://docs.blockvectra.com/en/guides/websocket-subscriptions/)

[Создать подписку Webhook](https://blockvectra.com/ru/webhooks/) · [Создать подписку Webhook](https://docs.blockvectra.com/en/guides/webhook-push/) · [Использование и CU](https://console.blockvectra.com/usage/) · [Пополнить баланс](https://console.blockvectra.com/billing/)

**HyperEVM**
Блоки HyperEVM включают системные транзакции HyperCore (с адреса 0x2222…2222 или 0x20…, gasPrice 0).
Отправка транзакций в этой сети пока не поддерживается (`eth_sendRawTransaction` возвращает `-32601` `method_not_allowed`); методы чтения работают в обычном режиме.

[Текущий статус →](https://blockvectra.com/ru/status/)

Все примеры на этой странице используют `robinhood_mainnet`.

> **Совет**: выберите в матрице выше сеть, поддерживающую нужный сервис, метод и окно истории для примера, а затем замените `robinhood_mainnet` на соответствующее имя `{chain}`. Один и тот же API key работает во всех поддерживаемых сетях.

### Другие варианты аутентификации и примеры на разных языках

Эндпоинты JSON-RPC привязаны к сети: `POST /v1/{chain}/{api_key}` с ключом в пути или `POST /v1/{chain}` с ключом в заголовке `x-api-key`. `{chain}` — это имя сети, которое также используется в Data API; для Robinhood Chain это `robinhood_mainnet`, поэтому эндпоинт на этой странице имеет вид `https://api.blockvectra.com/v1/robinhood_mainnet`. Вызов `eth_subscribe` по HTTP возвращает `-32601`; подписки WebSocket перечислены для каждой сети в разделе [Поддерживаемые сети](https://docs.blockvectra.com/ru/chains/). API отправляет заголовок `Access-Control-Allow-Origin: *`, однако вам следует хранить свой API key в секрете и выполнять запросы из бэкенд-сервиса, а не из клиентского кода браузера.

Вы можете передать ключ одним из трех способов: в пути URL (`POST /v1/{chain}/{api_key}`, при этом используется только ключ из пути, а оба заголовка игнорируются), в заголовке `x-api-key` или в заголовке `Authorization: Bearer <api_key>`.

#### Ключ в пути URL

**cURL**

```bash
: "${BLOCKVECTRA_API_KEY:?Set BLOCKVECTRA_API_KEY first}"

curl -s "https://api.blockvectra.com/v1/robinhood_mainnet/$BLOCKVECTRA_API_KEY" \
  -H 'Content-Type: application/json' \
  -d '{"jsonrpc":"2.0","id":1,"method":"eth_blockNumber","params":[]}'
```


  **TypeScript**

```ts
import { createPublicClient, http } from "viem";

const key = process.env.BLOCKVECTRA_API_KEY!;
const client = createPublicClient({
  transport: http(`https://api.blockvectra.com/v1/robinhood_mainnet/${key}`),
});

console.log(await client.getBlockNumber());

// Run with: npx tsx example.mts
```

Complete starter template: [blockvectra/multichain-viem](https://github.com/blockvectra/multichain-viem)


  **Python**

```python
import os

from web3 import Web3

w3 = Web3(Web3.HTTPProvider("https://api.blockvectra.com/v1/robinhood_mainnet/" + os.environ["BLOCKVECTRA_API_KEY"]))
print(w3.eth.block_number)
```


  **Go**

```go
// Run with: go mod init example && go get github.com/ethereum/go-ethereum && go mod tidy && go run .
package main

import (
	"context"
	"fmt"
	"log"
	"os"

	"github.com/ethereum/go-ethereum/ethclient"
)

func main() {
	client, err := ethclient.Dial("https://api.blockvectra.com/v1/robinhood_mainnet/" + os.Getenv("BLOCKVECTRA_API_KEY"))
	if err != nil {
		log.Fatal(err)
	}
	number, err := client.BlockNumber(context.Background())
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(number)
}
```


  **Rust**

```toml
[dependencies]
alloy = { version = "1", features = ["provider-http", "rpc-types"] }
tokio = { version = "1", features = ["macros", "rt-multi-thread"] }
```

```rust
use alloy::providers::{Provider, ProviderBuilder};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let key = std::env::var("BLOCKVECTRA_API_KEY")?;
    let url = format!("https://api.blockvectra.com/v1/robinhood_mainnet/{key}");
    let provider = ProviderBuilder::new().connect_http(url.parse()?);
    println!("{}", provider.get_block_number().await?);
    Ok(())
}
```


#### Ключ в заголовке запроса

**cURL**

```bash
: "${BLOCKVECTRA_API_KEY:?Set BLOCKVECTRA_API_KEY first}"

curl -s "https://api.blockvectra.com/v1/robinhood_mainnet" \
  -H 'Content-Type: application/json' \
  -H "x-api-key: $BLOCKVECTRA_API_KEY" \
  -d '{"jsonrpc":"2.0","id":1,"method":"eth_blockNumber","params":[]}'
```


  **TypeScript**

```ts
import { createPublicClient, http } from "viem";

const key = process.env.BLOCKVECTRA_API_KEY!;
const client = createPublicClient({
  transport: http("https://api.blockvectra.com/v1/robinhood_mainnet", {
    fetchOptions: { headers: { "x-api-key": key } },
  }),
});

console.log(await client.getBlockNumber());

// Run with: npx tsx example.mts
```


  **Python**

```python
import os

from web3 import Web3

key = os.environ["BLOCKVECTRA_API_KEY"]
# request_kwargs replaces the provider's default headers entirely, so
# Content-Type must be repeated here or the server can't parse the body.
headers = {"Content-Type": "application/json", "x-api-key": key}
w3 = Web3(Web3.HTTPProvider("https://api.blockvectra.com/v1/robinhood_mainnet", request_kwargs={"headers": headers}))
print(w3.eth.block_number)
```


  **Go**

```go
// Run with: go mod init example && go get github.com/ethereum/go-ethereum && go mod tidy && go run .
package main

import (
	"context"
	"fmt"
	"log"
	"os"

	"github.com/ethereum/go-ethereum/ethclient"
	"github.com/ethereum/go-ethereum/rpc"
)

func main() {
	ctx := context.Background()
	c, err := rpc.DialOptions(ctx, "https://api.blockvectra.com/v1/robinhood_mainnet", rpc.WithHeader("x-api-key", os.Getenv("BLOCKVECTRA_API_KEY")))
	if err != nil {
		log.Fatal(err)
	}
	number, err := ethclient.NewClient(c).BlockNumber(ctx)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(number)
}
```


  **Rust**

```toml
[dependencies]
alloy = { version = "1", features = ["provider-http", "rpc-types"] }
tokio = { version = "1", features = ["macros", "rt-multi-thread"] }
reqwest = "0.13"
```

```rust
use alloy::providers::{Provider, ProviderBuilder};
use alloy::rpc::client::RpcClient;
use reqwest::header::{HeaderMap, HeaderValue};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let key = std::env::var("BLOCKVECTRA_API_KEY")?;

    let mut headers = HeaderMap::new();
    headers.insert("x-api-key", HeaderValue::from_str(&key)?);
    let http_client = reqwest::Client::builder().default_headers(headers).build()?;

    let rpc_client = RpcClient::new_http_with_client(http_client, "https://api.blockvectra.com/v1/robinhood_mainnet".parse()?);
    let provider = ProviderBuilder::new().connect_client(rpc_client);

    println!("{}", provider.get_block_number().await?);
    Ok(())
}
```


> **Без завершающего слэша**
>
> При передаче ключа в заголовке вызывайте `https://api.blockvectra.com/v1/robinhood_mainnet` точно так, как показано: URL заканчивается
>   именем сети, **без** завершающего слэша. JSON-RPC обслуживается только по путям `/v1/{chain}`
>   и `/v1/{chain}/{api_key}`. Завершающий слэш (например, `/v1/{chain}/`) или запрос без сегмента сети (например, `/v1` или `/v1/`) возвращает `404` с пустым телом.


Заголовок `Authorization: Bearer <api_key>` также поддерживается. При запросе `POST /v1/{chain}` непустой
заголовок `x-api-key` имеет приоритет перед Bearer, а Bearer используется только в том случае, если `x-api-key` отсутствует
или пуст. Формат с ключом в пути игнорирует оба заголовка.

### Пакетные запросы

Отправьте массив, чтобы выполнить несколько вызовов в одном запросе (до 100 вызовов в пакете). Обратите внимание, что каждый API key имеет корзину CU (пополнение `cu_per_sec`, емкость `burst_cu` — по умолчанию 400 CU/s и всплеск (burst) 1,600 CU; отображается для каждого ключа в таблице Keys в консоли); отдельный запрос (включая весь пакет JSON-RPC), суммарный объем CU которого превышает емкость burst ключа, отклоняется с ошибкой `-32022 request_exceeds_burst` даже при соблюдении лимита в 100 вызовов на пакет; разделите его на более мелкие пакеты. В этом примере за один цикл запроса считываются
идентификатор сети и баланс аккаунта:

**cURL**

```bash
curl -s "https://api.blockvectra.com/v1/robinhood_mainnet" \
  -H 'Content-Type: application/json' \
  -H "x-api-key: $BLOCKVECTRA_API_KEY" \
  -d '[
    {"jsonrpc":"2.0","id":1,"method":"eth_chainId"},
    {"jsonrpc":"2.0","id":2,"method":"eth_getBalance","params":["0x1111111111111111111111111111111111111111","latest"]}
  ]'
```


  **TypeScript**

```ts
import { createPublicClient, http } from "viem";

const key = process.env.BLOCKVECTRA_API_KEY!;
const client = createPublicClient({
  transport: http("https://api.blockvectra.com/v1/robinhood_mainnet", {
    batch: true,
    fetchOptions: { headers: { "x-api-key": key } },
  }),
});

// viem coalesces concurrent requests into a single JSON-RPC batch.
const [chainId, balance] = await Promise.all([
  client.getChainId(),
  client.getBalance({ address: "0x1111111111111111111111111111111111111111" }),
]);
console.log(chainId, balance);

// Run with: npx tsx example.mts
```


  **Python**

```python
import os

from web3 import Web3

key = os.environ["BLOCKVECTRA_API_KEY"]
headers = {"Content-Type": "application/json", "x-api-key": key}
w3 = Web3(Web3.HTTPProvider("https://api.blockvectra.com/v1/robinhood_mainnet", request_kwargs={"headers": headers}))

with w3.batch_requests() as batch:
    batch.add(w3.eth.chain_id)
    batch.add(w3.eth.get_balance("0x1111111111111111111111111111111111111111"))
    chain_id, balance = batch.execute()

print(chain_id, balance)
```


  **Go**

```go
// Run with: go mod init example && go get github.com/ethereum/go-ethereum && go mod tidy && go run .
package main

import (
	"context"
	"fmt"
	"log"
	"os"

	"github.com/ethereum/go-ethereum/rpc"
)

func main() {
	ctx := context.Background()
	c, err := rpc.DialOptions(ctx, "https://api.blockvectra.com/v1/robinhood_mainnet", rpc.WithHeader("x-api-key", os.Getenv("BLOCKVECTRA_API_KEY")))
	if err != nil {
		log.Fatal(err)
	}

	var chainID, balance string
	calls := []rpc.BatchElem{
		{Method: "eth_chainId", Result: &chainID},
		{Method: "eth_getBalance", Args: []any{"0x1111111111111111111111111111111111111111", "latest"}, Result: &balance},
	}
	if err := c.BatchCallContext(ctx, calls); err != nil {
		log.Fatal(err)
	}
	for _, call := range calls {
		if call.Error != nil {
			log.Fatal(call.Error)
		}
	}
	fmt.Println(chainID, balance)
}
```


  **Rust**

```toml
[dependencies]
alloy = { version = "1", features = ["provider-http", "rpc-types"] }
tokio = { version = "1", features = ["macros", "rt-multi-thread"] }
reqwest = "0.13"
```

```rust
use alloy::primitives::{Address, U256};
use alloy::rpc::client::RpcClient;
use reqwest::header::{HeaderMap, HeaderValue};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let key = std::env::var("BLOCKVECTRA_API_KEY")?;

    let mut headers = HeaderMap::new();
    headers.insert("x-api-key", HeaderValue::from_str(&key)?);
    let http_client = reqwest::Client::builder().default_headers(headers).build()?;
    let rpc_client = RpcClient::new_http_with_client(http_client, "https://api.blockvectra.com/v1/robinhood_mainnet".parse()?);

    let address: Address = "0x1111111111111111111111111111111111111111".parse()?;
    let mut batch = rpc_client.new_batch();
    let chain_id = batch.add_call::<_, U256>("eth_chainId", &())?;
    let balance = batch.add_call::<_, U256>("eth_getBalance", &(address, "latest"))?;
    batch.send().await?;

    println!("{} {}", chain_id.await?, balance.await?);
    Ok(())
}
```


Ответы возвращаются в виде массива в том же порядке, что и запросы, сопоставляясь по полю `id`.

Если сервер отклоняет пакет целиком (недостаточный баланс, ограничение частоты запросов, превышение burst-лимита или превышение допустимого размера пакета; см. [Распространенные ошибки](#common-errors) ниже), он возвращает один объект ошибки JSON-RPC вместо массива; в режиме viem `batch: true` это отображается как неинформативная ошибка `UnknownRpcError`, поэтому повторите одиночный вызов, чтобы увидеть фактическую ошибку.

### Тарификация Compute Units (CU)

Каждый тарифицируемый вызов расходует **Compute Units (CU)**: простые вызовы, такие как `eth_blockNumber` или
`eth_chainId`, стоят меньше всего, стандартные операции чтения вроде `eth_getBlockByNumber` стоят немного больше, более тяжелые
вызовы, такие как `eth_call` или `eth_getLogs`, стоят еще дороже, а методы трассировки выполнения (например, `debug_traceTransaction`) обходятся дороже всего.
Плата за использование списывается с аккаунта за каждый почасовой период с округлением в меньшую сторону до целых расчетных единиц (1 единица = 1,000 CU), а остаток переносится на следующий период (таким образом, суммарно за все периоды списывается `floor(всего CU / 1,000)`); расчет происходит примерно через 15 минут после окончания периода. Например: 508 CU перенесенных + 2557 CU потребленных = 3065 CU, в результате чего списываются 3 расчетные единицы и 65 CU переносятся на следующий период. Актуальные цены см. в разделе [Цены](https://blockvectra.com/ru/pricing/).

Полная таблица весов каждого метода и коды ошибок представлены в
разделе [Справочник API → JSON-RPC](https://docs.blockvectra.com/ru/api/json-rpc/) — на этой странице рассматривается только
формат запросов.

#### Распространенные ошибки

| Что вы сделали                                                                                                                                                                                                                                                                     | Что возвращается                                                              | Действие                                                                                                                                                                                                                                                                                                                                     |
| ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Неизвестная или еще не открытая публично сеть                                                                                                                                                                                                                                      | HTTP `404` с JSON-телом `error.data.reason: "unknown_chain"`                  | Проверьте имя сети в URL                                                                                                                                                                                                                                                                                                                     |
| Запрос без сегмента сети (например, `/v1` или `/v1/`)                                                                                                                                                                                                                              | HTTP `404` с пустым телом                                                     | Укажите имя сети в URL (`/v1/{chain}`)                                                                                                                                                                                                                                                                                                       |
| API key отсутствует, неизвестен или отключен                                                                                                                                                                                                                                       | HTTP `401`, код JSON-RPC `-32024` (`missing_api_key` или `invalid_api_key`)   | Используйте действующий активный API key (новые или смененные ключи вступают в силу на всех инстансах примерно в течение 5 секунд; в это время они могут возвращать 401 `invalid_api_key` или 503 `-32021` (с заголовком `Retry-After`), если биллинговое состояние временно не подтверждено, поэтому подождите немного и повторите попытку) |
| Баланс равен нулю или отрицательный                                                                                                                                                                                                                                                | HTTP `402`, код JSON-RPC `-32020`                                             | Пополните баланс или дождитесь бесплатного начисления                                                                                                                                                                                                                                                                                        |
| Запросы отправляются слишком часто (ограничение частоты или временная перегрузка)                                                                                                                                                                                                  | HTTP `429` (или `200`), код JSON-RPC `-32005`                                 | Повторите попытку позже (соблюдайте `Retry-After` при наличии)                                                                                                                                                                                                                                                                               |
| Отдельный запрос или пакет превышает burst-емкость ключа (`burst_cu`, по умолчанию 1,600 CU; скорость по умолчанию 400 CU/s), либо пакет бесплатного плана превышает лимит вызовов/с (25 вызовов/с)                                                                                                                                                                                 | HTTP `429`, код JSON-RPC `-32022` (`request_exceeds_burst`)                   | Разделите запрос на более мелкие пакеты (в текущем виде он никогда не выполнится)                                                                                                                                                                                                                                                            |
| Вышестоящий узел временно недоступен                                                                                                                                                                                                                                               | HTTP `200`, код JSON-RPC `-32603` (`upstream unavailable`), не тарифицируется | Повторите запрос                                                                                                                                                                                                                                                                                                                             |
| Историческое состояние за пределами окна состояния сети (см. `state_window_blocks` в `GET /v1/chains`)                                                                                                                                                                             | HTTP `200`, код JSON-RPC `-32011`, не тарифицируется                          | Запросите более недавний блок                                                                                                                                                                                                                                                                                                                |
| Транзакция или блок не найдены, либо ответ слишком велик; в Ethereum запросы блоков, квитанций и логов за пределами недавнего окна также возвращают -32000 "old data not available due to pruning" (не тарифицируется; см. [Поддерживаемые сети → Ethereum](https://docs.blockvectra.com/ru/chains/#ethereum)) | HTTP `200`, код JSON-RPC `-32000`                                             | Измените запрос (проверьте хеш или номер блока; некорректные хеши трассировки возвращают ошибку "transaction not found")                                                                                                                                                                                                                     |
| Трейсер не разрешен, или превышен таймаут трассировки (вызовы `debug_trace`)                                                                                                                                                                                                       | HTTP `200`, код JSON-RPC `-32602`, не тарифицируется                          | Используйте разрешенный нативный трейсер (`callTracer`, `flatCallTracer`, `prestateTracer`, `4byteTracer`, `noopTracer` или опустите параметр) и таймаут ≤ 30 с                                                                                                                                                                              |
| Метод не разрешен списком методов данной сети (см. [Поддерживаемые сети](https://docs.blockvectra.com/ru/chains/))                                                                                                                                                                                             | HTTP `200`, код JSON-RPC `-32601`, не тарифицируется                          | Вызывайте только разрешенные для сети методы                                                                                                                                                                                                                                                                                                 |
| Некорректный синтаксис JSON в теле запроса                                                                                                                                                                                                                                         | HTTP `200`, код JSON-RPC `-32700`, не тарифицируется                          | Исправьте синтаксис JSON в запросе                                                                                                                                                                                                                                                                                                           |
| Более 100 вызовов в одном пакете                                                                                                                                                                                                                                                   | HTTP `200`, код JSON-RPC `-32600` (`batch too large`), не тарифицируется      | Разделите пакет так, чтобы в нем было не более 100 вызовов                                                                                                                                                                                                                                                                                   |

Перечисленные выше отклоненные запросы никогда не тарифицируются. За каждый принятый вызов, получивший ответ, взимается плата в соответствии с опубликованным весом метода в CU; в таблице кодов ошибок перечислены случаи, которые не тарифицируются (см. колонку Billed в разделе [Коды ошибок](https://docs.blockvectra.com/ru/api/json-rpc/#error-codes)).

### Вызовы Data API

Data API предоставляет доступ к данным блокчейна только для чтения (блоки, транзакции, балансы, держатели, активность на DEX
и многое другое) в формате REST/JSON. Все маршруты, за исключением `GET https://api.blockvectra.com/v1/data/chains`, содержат префикс
с идентификатором сети: `robinhood_mainnet` — это идентификатор сети (поле `chain`, возвращаемое эндпоинтом `/chains` и в объекте `meta`), используемый во всех приведенных ниже путях.
Эндпоинт `GET https://api.blockvectra.com/v1/data/chains` возвращает список только публичных сетей и только поле `{"data": [...]}` (без
`meta` и `next_cursor`). Запросы измеряются и тарифицируются в Compute Units (CU); тарифицируются только успешные ответы 2xx.

Для каждого запроса требуется тот же API key, что и для JSON-RPC — передавайте его в заголовке `x-api-key`.
Каждый успешный ответ, привязанный к сети, использует единую структуру обертки:
`data` (полезная нагрузка), `next_cursor` (непрозрачная строка, присутствует только при наличии следующей страницы — в противном случае
ключ отсутствует вовсе, никогда не равен `null`) и `meta` (`chain`, `chain_slug` (верхний регистр `chain`), `chain_external_id`,
`as_of_block`, `safe_block`, `finalized_block`, `coverage`, `refreshed_at`; `refreshed_at` может быть `null`, что означает неизвестное время обновления данных и необходимость считать их устаревшими — эндпоинты на основе блоков всегда возвращают значение). Ответы с ошибками обычно содержат `{"error":{"code","message"}}` —
`409 not_indexed_yet` дополнительно возвращает `indexed_through` (наибольший проиндексированный блок). Неизвестная или непубличная сеть возвращает HTTP `404` с `error.code` `not_found` (не тарифицируется; имена сетей должны быть точными слагами в нижнем регистре); отсутствующий, неизвестный или отключенный API key возвращает HTTP `401` с `error.code` `missing_api_key` или `invalid_api_key`. Запросы, превысившие лимит частоты, возвращают HTTP `429` (`error.code` `rate_limited`, `data.reason: "key_rate_limit"`), а при исчерпании баланса возвращается HTTP `402` (`error.code` `insufficient_balance`); оба случая не тарифицируются. Значения, которые могут превышать 2^53 (балансы, объемы токенов), передаются в виде десятичных
строк, а не JSON-чисел.

**Получение блока по номеру:**

**cURL**

```bash
curl -s "https://api.blockvectra.com/v1/data/robinhood_mainnet/blocks/72838701" \
  -H "x-api-key: $BLOCKVECTRA_API_KEY"
```


  **TypeScript**

```ts
const res = await fetch("https://api.blockvectra.com/v1/data/robinhood_mainnet/blocks/72838701", {
  headers: { "x-api-key": process.env.BLOCKVECTRA_API_KEY! },
});
const body = await res.json();
console.log(body);

// Run with: npx tsx example.mts
```


  **Python**

```python
import os, requests

res = requests.get(
    "https://api.blockvectra.com/v1/data/robinhood_mainnet/blocks/72838701",
    headers={"x-api-key": os.environ["BLOCKVECTRA_API_KEY"]},
)
print(res.json())
```


```json
{
  "data": {
    "number": 72838701,
    "hash": "0x9f2c1e7a4b6d3f805e1c9a72b4d6f1e0a3c8b5d7e2f4a1c6b9d3e7f0a2c4b6d8",
    "parent_hash": "0x1a3c5e7f9b1d3f5a7c9e1b3d5f7a9c1e3b5d7f9a1c3e5b7d9f1a3c5e7b9d1f3a",
    "timestamp": "2026-09-26T05:41:07Z",
    "miner": "0x00000000000000000000000000000000000a4b05",
    "gas_limit": 32000000,
    "gas_used": 4821932,
    "base_fee_per_gas": "100000000",
    "state_root": "0x2b4d6f8a1c3e5b7d9f1a3c5e7b9d1f3a5c7e9b1d3f5a7c9e1b3d5f7a9c1e3b5d",
    "transactions_root": "0x3c5e7b9d1f3a5c7e9b1d3f5a7c9e1b3d5f7a9c1e3b5d7f9a1c3e5b7d9f1a3c5e",
    "receipts_root": "0x4d6f8a1c3e5b7d9f1a3c5e7b9d1f3a5c7e9b1d3f5a7c9e1b3d5f7a9c1e3b5d7f",
    "tx_count": 239,
    "size": 48213,
    "l1_block_number": null,
    "extra": {}
  },
  "meta": {
    "chain": "robinhood_mainnet",
    "chain_slug": "ROBINHOOD_MAINNET",
    "chain_external_id": "eip155:4663",
    "as_of_block": 72838957,
    "safe_block": 72838800,
    "finalized_block": 72838701,
    "coverage": "full",
    "refreshed_at": "2026-09-27T02:15:03Z"
  }
}
```

Номер блока выше проиндексированной вершины (`as_of_block`) возвращает `409` (`error.code: "not_indexed_yet"`) с полем `indexed_through`, указывающим на наивысший проиндексированный блок — данные еще не готовы, повторите попытку позже. Номер блока, предшествующий покрываемой истории сети (`coverage.from_block`), возвращает `422` (`error.code: "no_coverage"`). В пределах диапазона покрытия номер блока на уровне или ниже `as_of_block` при отсутствии активной записи (никогда не индексировался или откатился в результате реорганизации) возвращает `404` (`error.code: "not_found"`).

**Проверка свежести данных** (насколько каждый отслеживаемый набор данных отстает от вершины сети — полезно
для страницы статуса или предварительной проверки перед отправкой запроса):

**cURL**

```bash
curl -s "https://api.blockvectra.com/v1/data/robinhood_mainnet/status/freshness" \
  -H "x-api-key: $BLOCKVECTRA_API_KEY"
```


  **TypeScript**

```ts
const res = await fetch("https://api.blockvectra.com/v1/data/robinhood_mainnet/status/freshness", {
  headers: { "x-api-key": process.env.BLOCKVECTRA_API_KEY! },
});
const body = await res.json();
console.log(body);

// Run with: npx tsx example.mts
```


  **Python**

```python
import os, requests

res = requests.get(
    "https://api.blockvectra.com/v1/data/robinhood_mainnet/status/freshness",
    headers={"x-api-key": os.environ["BLOCKVECTRA_API_KEY"]},
)
print(res.json())
```


```json
{
  "data": [
    {
      "dataset": "blocks",
      "category": "raw",
      "max_block_number": 72838957,
      "max_day": null,
      "max_time": "2026-09-27T02:15:01Z",
      "seconds_behind": 0,
      "blocks_behind": null,
      "days_behind": null,
      "checked_at": "2026-09-27T02:15:07Z"
    }
  ],
  "meta": {
    "chain": "robinhood_mainnet",
    "chain_slug": "ROBINHOOD_MAINNET",
    "chain_external_id": "eip155:4663",
    "as_of_block": 72838957,
    "safe_block": 72838800,
    "finalized_block": 72838701,
    "coverage": "full",
    "refreshed_at": "2026-09-27T02:15:07Z"
  }
}
```

*(Сокращено: в ответе возвращается по одной строке для каждого набора данных; показана только строка `blocks`. В строке `traces` также содержатся поля `coverage_from_block`, `coverage_to_block` и `coverage_complete`.)*

Если данные о свежести для данной сети временно недоступны, возвращается `503` (`error.code: "unavailable"`) вместо частичного результата; ответ содержит заголовок `Retry-After` (в секундах) — подождите указанное время перед повторным запросом.

**Список балансов ERC-20 для адреса** (снимок ненулевых
балансов с сортировкой по токену):

**cURL**

```bash
curl -s "https://api.blockvectra.com/v1/data/robinhood_mainnet/addresses/0x1111111111111111111111111111111111111111/balances" \
  -H "x-api-key: $BLOCKVECTRA_API_KEY"
```


  **TypeScript**

```ts
const res = await fetch(
  "https://api.blockvectra.com/v1/data/robinhood_mainnet/addresses/0x1111111111111111111111111111111111111111/balances",
  { headers: { "x-api-key": process.env.BLOCKVECTRA_API_KEY! } },
);
const body = await res.json();
console.log(body);

// Run with: npx tsx example.mts
```


  **Python**

```python
import os, requests

res = requests.get(
    "https://api.blockvectra.com/v1/data/robinhood_mainnet/addresses/0x1111111111111111111111111111111111111111/balances",
    headers={"x-api-key": os.environ["BLOCKVECTRA_API_KEY"]},
)
print(res.json())
```


```json
{
  "data": [
    { "token": "0x0bd7d308f8e1639fab988df18a8011f41eacad73", "balance": "185371464119396", "symbol": "WETH", "decimals": 18 },
    { "token": "0x2295f15bd4914ae9b4685f01d52f4e6f89bf8b03", "balance": "10000000000000000", "symbol": "WNVDA", "decimals": 18 }
  ],
  "meta": {
    "chain": "robinhood_mainnet",
    "chain_slug": "ROBINHOOD_MAINNET",
    "chain_external_id": "eip155:4663",
    "as_of_block": 72838957,
    "safe_block": 72838800,
    "finalized_block": 72838701,
    "coverage": "full",
    "refreshed_at": "2026-09-27T02:10:00Z"
  }
}
```

Для адреса без ненулевых балансов по-прежнему возвращается `200` с `data: []` — никогда не `404`.
Передавайте параметр `?limit=` (по умолчанию 50, максимум 500) и возвращаемый `next_cursor` для постраничной навигации.

Полный перечень эндпоинтов — блоки, транзакции, адреса, токены, NFT, DEX, токенизированные
акции — доступен в разделе [Справочник API → Data API](https://docs.blockvectra.com/ru/api/data/).

### Дополнительные материалы

* [Справочник API → JSON-RPC](https://docs.blockvectra.com/ru/api/json-rpc/) — методы, веса CU, коды ошибок
* [Полный справочник JSON-RPC](https://docs.blockvectra.com/ru/api/json-rpc/reference/) — полные спецификации, параметры и схемы ответов для всех поддерживаемых методов
* [Справочник API → Data API](https://docs.blockvectra.com/ru/api/data/) — REST-эндпоинты для данных блокчейна
* [Наборы данных](https://docs.blockvectra.com/ru/datasets/) — производные наборы данных по поддерживаемым сетям
* [Руководства](https://docs.blockvectra.com/ru/guides/) — практические руководства по интеграции API, управлению CU и мультичейн-процессам
* [Поддерживаемые сети](https://docs.blockvectra.com/ru/chains/) — идентификаторы сетей и URL эндпоинтов

## FAQ

### Какие сети поддерживаются?

Количество поддерживаемых сетей — 9: Arbitrum One, Base, BNB Smart Chain, Ethereum, Ethereum Sepolia, HyperEVM, Polygon, Robinhood Chain, Robinhood Chain Testnet. Список соответствует GET /v1/chains и обновляется при добавлении новых сетей. Текущий статус смотрите на [странице статуса](https://blockvectra.com/ru/status/). [Поддерживаемые сети](https://blockvectra.com/ru/chains/)

### Поддерживается ли WebSocket?

Вызов eth_subscribe по HTTP возвращает -32601; в сетях, где ws равен true в /v1/chains, eth_subscribe доступен через WebSocket. В остальных случаях выполняйте опрос через eth_getLogs. [Поддерживаемые сети](https://blockvectra.com/ru/chains/)

### Можно ли запрашивать историческое состояние и трассировки?

Да, но это зависит от сети. Окно исторического состояния задается полем state_window_blocks в /v1/chains (значение null означает полную историю); доступность трассировок зависит от наличия методов debug_trace (например, debug_traceTransaction) в methods.allow для этой сети; максимальный диапазон блоков для одного запроса eth_getLogs определяется параметром max_logs_block_range. [Каталог сетей и параметры для каждой сети](https://blockvectra.com/ru/chains/)

### Можно ли использовать один API key для всех сетей?

Да. Один API key работает для JSON-RPC во всех поддерживаемых сетях и для Data API в сетях с его поддержкой; ключ привязан к аккаунту, а не к конкретной сети. [Руководство «Один ключ для множества сетей»](https://docs.blockvectra.com/en/guides/one-key-many-chains/)