# AI Agent'lar için blokzincir RPC ve belge MCP'si

> Source: https://docs.blockvectra.com/tr/guides/ai-agents/

Blokzincir RPC yöntemlerini, Data API veri kümelerini, fiyatları ve belgeleri keşfetmek için anahtarsız [belge MCP uç noktası](https://docs.blockvectra.com/mcp) ile başlayın. AI Agent'lar birinci sınıf kullanıcılardır: geliştiriciler ve AI Agent'lar aynı API'leri, kuralları, sınırları ve fiyatları kullanır.

1. **Keşfedin**: bir zincir ve yöntem seçmek için belge MCP'sini, `llms.txt` dosyasını, OpenAPI'yi ve genel JSON'u kullanın. Anahtarsız RPC çağrıları zincirin `public.methods` listesiyle sınırlıdır.
2. **HTTP üzerinden bir hesap açın**: bir cüzdan imzasıyla oturum açmak ve bir API key oluşturmak için [programatik kayıt](https://docs.blockvectra.com/en/guides/programmatic-signup/) adımlarını izleyin. MCP'nin `how_to_get_api_key` aracı, bu ayrı HTTP akışı için talimatlar döndürür.
3. **Veri API'lerini çağırın**: anahtarı `BLOCKVECTRA_API_KEY` içinde tutun ve kimlik doğrulamalı RPC veya Data API istekleri için kullanın. Anahtar gerektiren MCP araçları için istemcinin `x-api-key` başlığını yapılandırın; her aracın izin verilen işlemleri aşağıda listelenmiştir.

## 1. Makine tarafından okunabilir bağlam ve spesifikasyonlar

BlockVectra, LLM ajanlarını ve geliştirici araçlarını hedefleyen dosyalar yayınlar:

### llms.txt dizinleri

[llmstxt.org](https://llmstxt.org) standardını takip eden bu dosyalar, ajanlara sitenin ve uç noktalarının yapılandırılmış bir özetini sunar:

* **Ana site dizini**: [Ana site llms.txt](https://blockvectra.com/llms.txt) — ana sitenin, desteklenen zincirlerin, fiyatlandırmanın ve herkese açık API'lerin genel görünümü.
* **Belgeler dizini**: [Belgeler llms.txt](https://docs.blockvectra.com/llms.txt) — başlığı ve açıklamasıyla birlikte her belge sayfasının kataloğu.

### Tam dokümantasyon dosyası (`llms-full.txt`)

* **Eksiksiz dokümantasyon**: [llms-full.txt](https://docs.blockvectra.com/llms-full.txt) — tek bir düz metin Markdown dosyasında her İngilizce dokümantasyon sayfasının tam metni; bir ajanın sistem istemine yüklemek veya bir Alma ile Zenginleştirilmiş Üretim (RAG) ardışık düzenine aktarmak için uygundur.

### İndirilebilir OpenAPI 3.1 spesifikasyonları

Dokümantasyon sitesi, doğrudan ajan çerçevelerine, araç oluşturuculara veya API istemcilerine aktarılabilen OpenAPI 3.1 YAML dosyaları sunar:

* **JSON-RPC API spesifikasyonu**: [/openapi/json-rpc.yaml](https://docs.blockvectra.com/openapi/json-rpc.yaml) — desteklenen yöntemler, zincir başına yöntem politikası, hata yanıtları ve Compute Unit ölçümü.
* **Data API spesifikasyonu**: [/openapi/data.yaml](https://docs.blockvectra.com/openapi/data.yaml) — indekslenmiş bloklar, işlemler, transferler, bakiyeler, sahipler ve ilgili veri kümeleri için REST uç nokta tanımları.
* **Push API spesifikasyonu**: [/openapi/push.yaml](https://docs.blockvectra.com/openapi/push.yaml) — HTTP abonelik yönetimi, izlenen cüzdan adresleri, webhook olayları, imzalar ve yeniden oynatma.

Cüzdan adresi aktivitesi için [Blokzincir Webhook API rehberini](https://docs.blockvectra.com/en/guides/webhook-push/) takip edin. ERC-20 USDT / USDC ödeme bildirimleri için [ödeme alıcısı örneğini](https://docs.blockvectra.com/en/guides/stablecoin-payments/#receive-payments-with-webhooks) kullanın. Geliştiriciler ve AI Agent'lar `x-api-key` ile HTTP Push API üzerinden abonelikler oluşturur ve yönetir; belge MCP'si bu rehberlerin keşfedilmesini ve okunmasını sağlar.

Yol sürüm oluşturma, geriye dönük uyumluluk kuralları ve ajanlar ile SDK yazarları için öneriler için [API sürüm oluşturma ve uyumluluk](https://docs.blockvectra.com/en/api/versioning/) sayfasına bakın. Popüler çerçevelerde (ElizaOS, viem, wagmi, Coinbase AgentKit) kullanıma hazır tarifler için [Agent çerçevesi tarifleri](https://docs.blockvectra.com/en/guides/agent-frameworks/) sayfasına bakın.

### Model Context Protocol (MCP) sunucusu

BlockVectra, Streamable HTTP üzerinden durum bilgisi olmayan, anahtarsız bir MCP sunucusu sunar:

* **Uç nokta**: [MCP uç noktası](https://docs.blockvectra.com/mcp) (JSON-RPC 2.0 alan HTTP POST; GET 405 döndürür)
* **Aktarım**: MCP Streamable HTTP (durum bilgisi tutmayan, API key gerektirmeyen)

#### Kullanılabilir araçlar

1. `read_doc(path, lang?)`: `/md/{lang}/{path}.md` üzerinden herhangi bir dokümantasyon sayfası için ham Markdown içeriği döndürür. Dahili göreli yolları kabul eder (örneğin `quickstart`, `guides/ai-agents`, `api/json-rpc`, `chains`).
2. `search_docs(query, lang?, limit?)`: dokümantasyon sayfalarını başlıklar, yollar ve özetler genelinde arar.
3. `list_chains()`: `GET /v1/chains` üzerinden desteklenen blokzincir ağlarını, statik parametreleri ve yöntem politikalarını okur.
4. `get_status()`: `GET /v1/status` üzerinden canlı hizmet hazırlığını, ağ durumunu, en son blok yüksekliklerini ve senkronizasyon gecikmesini okur.
5. `get_pricing()`: `GET /v1/plans` üzerinden Compute Unit (CU) ağırlıklarını, Ücretsiz Plan parametrelerini ve varsayılan anahtar sınırlarını okur.
6. `estimate_usage(lines?, method?, calls_per_day?)`: bir veya daha fazla yöntem için Compute Units (CU), brüt liste maliyeti ve döngü ücretsiz kotasını düştükten sonraki net maliyeti tahmin eder (çok satırlı `lines: [{method, calls_per_day}]` veya tek `method` ve `calls_per_day` destekler). Ayrıca `key_defaults` üzerinden anahtar başına hız sınırlarını bildirir ve trafik tek anahtar sınırlarını aştığında gereken API key sayısını önerir.
7. `how_to_get_api_key(lang?)`: JSON-RPC ve Data API için API key devir adımlarını ve istek kimlik doğrulama biçimlerini döndürür.
8. `get_method_info(method, chain?)`: bir yöntem için zincir kullanılabilirliğini, Compute Unit (CU) ağırlığını, milyon çağrı başına fiyatı ve dokümantasyon bağlantısını döndürür. JSON-RPC kullanılabilirliği `GET /v1/chains` içindeki `methods.allow` ve `deny` kurallarını takip eder; Data API veri kümesi kapsamı zincir kataloğunda `data: true` olmak üzere `GET /v1/status` içindeki `data_features` alanını takip eder.
9. `explain_error(reason?, code?, http_status?)`: hata kataloğundan hata açıklamalarını, faturalandırma etkilerini, yeniden denenebilirliği ve kurtarma eylemlerini arar.
10. `list_docs(lang?)`: dokümantasyon dizininden göreli yollar ve başlıklarla birlikte tüm dokümantasyon sayfalarını listeler.
11. `rpc_call(chain, method, params?)`: API key'iniz ile desteklenen bir zincirde salt okunur bir JSON-RPC 2.0 çağrısı yürütür (`readOnlyHint: true`). Yazma yöntemleri (`eth_sendRawTransaction` gibi) reddedilir; bunun yerine `send_raw_transaction` kullanın. Tam erişim için MCP istemci yapılandırmasında `x-api-key` başlığı gerektirir veya varsa anahtarsız herkese açık uç noktayı kullanır.
12. `data_api_get(chain, path, query?)`: API key'iniz ile desteklenen bir zincir ve yol için Data API'ye bir GET isteği gönderir (`readOnlyHint: true`). MCP istemci yapılandırmasında `x-api-key` başlığı gerektirir.
13. `get_account()`: API key'iniz ile `GET /v1/account` üzerinden hesap bakiyesini, Compute Units (CU), hız sınırlarını ve anahtar parametrelerini sorgular (`readOnlyHint: true`). MCP istemci yapılandırmasında `x-api-key` başlığı gerektirir.
14. `get_deposit_address()`: API key'iniz ile `GET /v1/topup/deposit-address` üzerinden özel zincir üstü yatırma adresini, açık ağları ve tokenları sorgular (`readOnlyHint: true`). Yalnızca listelenen ağlara ve tokenlara transfer yapın. MCP istemci yapılandırmasında `x-api-key` başlığı gerektirir.
15. `send_raw_transaction(chain, raw_tx)`: imzalanmış ham bir işlemi `eth_sendRawTransaction` aracılığıyla desteklenen bir zincire yayınlar (`destructiveHint: true`). Tam erişim için MCP istemci yapılandırmasında `x-api-key` başlığı gerektirir veya zincirde izin veriliyorsa anahtarsız herkese açık uç noktayı kullanır.

#### Anahtar gerektiren araçlar

Anahtar gerektiren araçlar; zincir üstü sorguları, işlemleri, Data API isteklerini veya hesap işlemlerini yürütmek için bir API key gerektirir.

**API key güvenliği**:

* **Yalnızca başlıklardan okunur**: API key yalnızca MCP istemcisi HTTP istek başlıklarından okunur (`x-api-key: rgw_...` veya `Authorization: Bearer rgw_...`).
* **Anahtarları asla sohbete koymayın**: API key'lerini veya özel anahtarları asla araç argümanlarında iletmeyin veya sohbete yapıştırmayın. Araç argümanları ve sohbet geçmişi konuşma günlüklerine ve bağlamlarına girer; argümanlarda anahtar iletmek reddedilir.

Bir API key başlığı olmadan çağrılırsa bu araçlar `isError: true` döndürür ve ajanı `how_to_get_api_key` aracına ve programatik kayıt rehberine yönlendirir.

### MCP istemcilerinden bağlanma

BlockVectra dokümantasyon MCP sunucusuna yaygın geliştirme ortamları ve çerçevelerinde `https://docs.blockvectra.com/mcp` adresinden bağlanabilirsiniz.

Bir API key olmadan başlayın. MCP uç noktasına bağlanın, list\_chains çağrısını yapın, ardından read\_doc ile quickstart belgesini okuyun. Data API veya hesap araçlarına ihtiyaç duyduğunuzda istemcinizin HTTP başlıklarına bir API key ekleyin. Anahtarsız RPC erişimi her zincirin genel yöntem politikasını takip eder.

`x-api-key` başlığı isteğe bağlıdır. Bir API key olmadan istemciler tüm salt okunur dokümantasyon araçlarını (`read_doc`, `search_docs`, `list_docs`), zincir keşfini (`list_chains`), canlı durumu (`get_status`), fiyatlandırma tahminini (`get_pricing`, `estimate_usage`), hata açıklamalarını (`explain_error`) ve genel uç noktalarda izin verilen yöntemleri kullanabilir. Anahtar gerektiren araçları (kısıtlı yöntemlerde `rpc_call`, `send_raw_transaction`, `data_api_get`, `get_account` ve `get_deposit_address`) kullanırken, `x-api-key` başlığını API key'iniz ile yapılandırın.

#### Claude Code

CLI kullanarak MCP sunucusuna bağlanın:

```bash
claude mcp add --transport http blockvectra-docs https://docs.blockvectra.com/mcp
```

Kimlik doğrulamalı araçlar için isteğe bağlı bir API key eklemek üzere `--header` (veya `-H`) seçeneğini iletin:

```bash
claude mcp add --transport http blockvectra-docs https://docs.blockvectra.com/mcp \
  --header "x-api-key: YOUR_API_KEY"
```

Resmi belgeler: [Claude Code MCP belgeleri](https://code.claude.com/docs/en/mcp).

#### Cursor

Sunucuyu Cursor'ın MCP yapılandırmasına ekleyin:

```json
{
  "mcpServers": {
    "blockvectra": {
      "url": "https://docs.blockvectra.com/mcp"
    }
  }
}
```

Cursor ayrıca `eyJ1cmwiOiJodHRwczovL2RvY3MuYmxvY2t2ZWN0cmEuY29tL21jcCJ9` (`{"url":"https://docs.blockvectra.com/mcp"}` temsil eden) base64 kodlu yapılandırmayı kullanarak derin bağlantılar aracılığıyla tek tıklamayla kurulumu destekler:

```text
cursor://anysphere.cursor-deeplink/mcp/install?name=blockvectra&config=eyJ1cmwiOiJodHRwczovL2RvY3MuYmxvY2t2ZWN0cmEuY29tL21jcCJ9
```

Kimlik doğrulamalı araçlara (Data API veya hesap yönetimi) ihtiyaç duyduğunuzda, `headers` nesnesini API key'iniz ile ekleyin:

```json
{
  "mcpServers": {
    "blockvectra": {
      "url": "https://docs.blockvectra.com/mcp",
      "headers": {
        "x-api-key": "YOUR_API_KEY"
      }
    }
  }
}
```

Resmi belgeler: [Cursor MCP belgeleri](https://cursor.com/docs/context/mcp) ve [Cursor kurulum bağlantıları](https://cursor.com/docs/context/mcp/install-links).

#### VS Code

VS Code'da sunucuyu `.vscode/mcp.json` içinde en üst düzey `servers` anahtarı altında `type: "http"` ile yapılandırın:

```json
{
  "servers": {
    "blockvectra": {
      "type": "http",
      "url": "https://docs.blockvectra.com/mcp"
    }
  }
}
```

Kimlik doğrulamalı araçlara ihtiyaç duyduğunuzda `headers` nesnesini ekleyin:

```json
{
  "servers": {
    "blockvectra": {
      "type": "http",
      "url": "https://docs.blockvectra.com/mcp",
      "headers": {
        "x-api-key": "YOUR_API_KEY"
      }
    }
  }
}
```

Hassas kimlik bilgilerini depolarken VS Code, anahtarları sabit kodlamak yerine girdi değişkenlerine veya ortam dosyalarına başvurmayı destekler. Sunucuları `MCP: Add Server` Komut Paleti eylemini kullanarak da ekleyebilirsiniz.

Resmi belgeler: [VS Code MCP sunucuları belgeleri](https://code.visualstudio.com/docs/copilot/customization/mcp-servers) ve [VS Code MCP yapılandırma referansı](https://code.visualstudio.com/docs/agents/reference/mcp-configuration).

#### Codex

OpenAI Codex CLI kullanarak sunucuyu ekleyin:

```bash
codex mcp add blockvectra --url https://docs.blockvectra.com/mcp
```

`config.toml` dosyasında sunucu URL'sini yapılandırın:

```toml
[mcp_servers.blockvectra]
url = "https://docs.blockvectra.com/mcp"
```

Kimlik doğrulamalı araçlara ihtiyaç duyduğunuzda, `config.toml` içinde istek başlıklarını yapılandırın:

```toml
[mcp_servers.blockvectra]
url = "https://docs.blockvectra.com/mcp"
http_headers = { "x-api-key" = "YOUR_API_KEY" }
```

Alternatif olarak başlığı bir ortam değişkeninden eşleyin:

```toml
[mcp_servers.blockvectra]
url = "https://docs.blockvectra.com/mcp"
env_http_headers = { "x-api-key" = "BLOCKVECTRA_API_KEY" }
```

Resmi belgeler: [OpenAI Codex CLI MCP belgeleri](https://learn.chatgpt.com/docs/extend/mcp?surface=cli).

#### Gemini CLI

Gemini CLI yapılandırmasında sunucuyu Streamable HTTP için `httpUrl` kullanarak `mcpServers` altına ekleyin:

```json
{
  "mcpServers": {
    "blockvectra": {
      "httpUrl": "https://docs.blockvectra.com/mcp"
    }
  }
}
```

Kimlik doğrulamalı araçlara ihtiyaç duyduğunuzda `headers` nesnesini API key'iniz ile ekleyin:

```json
{
  "mcpServers": {
    "blockvectra": {
      "httpUrl": "https://docs.blockvectra.com/mcp",
      "headers": {
        "x-api-key": "YOUR_API_KEY"
      }
    }
  }
}
```

Resmi belgeler: [Gemini CLI MCP sunucusu belgeleri](https://github.com/google-gemini/gemini-cli/blob/main/docs/tools/mcp-server.md).

#### OpenAI Responses API

OpenAI Responses API'yi çağırırken, MCP sunucusunu `tools` dizisinde `type: "mcp"` ile iletin:

```bash
OPENAI_API_BASE="https://api.openai.com/v1"
curl "$OPENAI_API_BASE/responses" \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "<model>",
    "tools": [{
      "type": "mcp",
      "server_label": "blockvectra",
      "server_url": "https://docs.blockvectra.com/mcp",
      "require_approval": "never"
    }],
    "input": "..."
  }'
```

Kimlik doğrulamalı araçlara ihtiyaç duyduğunuzda, araç tanımına `headers` alanını dahil edin:

```json
{
  "type": "mcp",
  "server_label": "blockvectra",
  "server_url": "https://docs.blockvectra.com/mcp",
  "headers": { "x-api-key": "YOUR_API_KEY" },
  "require_approval": "never"
}
```

Resmi belgeler: [OpenAI MCP araçları rehberi](https://developers.openai.com/api/docs/guides/tools-connectors-mcp) ve [OpenAI Responses API referansı](https://developers.openai.com/api/reference/resources/responses/methods/create).

#### Windsurf

Windsurf'te sunucuyu `mcpServers` altında `serverUrl` alanını kullanarak yapılandırın:

```json
{
  "mcpServers": {
    "blockvectra": {
      "serverUrl": "https://docs.blockvectra.com/mcp"
    }
  }
}
```

Kimlik doğrulamalı araçlara ihtiyaç duyduğunuzda `headers` nesnesini API key'iniz ile ekleyin:

```json
{
  "mcpServers": {
    "blockvectra": {
      "serverUrl": "https://docs.blockvectra.com/mcp",
      "headers": {
        "x-api-key": "YOUR_API_KEY"
      }
    }
  }
}
```

Windsurf ayrıca `"x-api-key": "${env:BLOCKVECTRA_API_KEY}"` gibi ortam değişkenlerine başvurmayı da destekler.

Resmi belgeler: [Windsurf MCP belgeleri](https://docs.devin.ai/desktop/cascade/mcp).

#### Claude Desktop ve claude.ai

Özel bağlayıcılar kullanıcı arayüzü üzerinden yapılandırılır:

* **claude.ai**: **Customize** > **Connectors** bölümüne gidin, **+ Add** seçeneğine tıklayın, **Add custom connector** seçin ve URL'yi girin:
  ```text
  https://docs.blockvectra.com/mcp
  ```
* **Claude Desktop**: Hesap ayarları menüsünü açın ve bağlayıcılar arayüzü üzerinden özel bağlayıcıları yapılandırın.

URL'ye bağlanmak; Claude'un rehberleri aramasını, Markdown belgelerini okumasını, desteklenen zincirleri incelemesini, ağ durumunu kontrol etmesini ve kimlik bilgileri olmadan fiyatlandırma tahminlerini hesaplamasını sağlar.

Resmi belgeler: [Claude özel bağlayıcılar rehberi](https://support.claude.com/en/articles/11175166-getting-started-with-custom-connectors-using-remote-mcp).

## 2. Herkese açık JSON uç noktaları (anahtar gerekmez)

Bir agent, herhangi bir faturalandırılan istek göndermeden önce mevcut zincirleri, canlı durumu ve plan parametrelerini inceleyebilir. Bu uç noktaların hiçbiri bir API key gerektirmez:

* `GET /v1/status` ve `GET /v1/chains` kimlik doğrulamasız ve faturalandırılmazdır.
* `GET /v1/plans` herkese açıktır ve kimlik doğrulamasızdır.

Her üçü de `Access-Control-Allow-Origin: *` gönderir.

### Hizmet durumu (`GET /v1/status`)

Hizmetin hazırlığını ve her bir genel zincirin senkronizasyon durumunu döndürür:

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

Yanıt alanları:

* `checked_at`: anlık görüntünün oluşturulduğu zaman (RFC 3339 / ISO 8601 UTC).
* `gateway.status`: hizmet çalışma durumu. `ok`, hizmetin hazır olduğu anlamına gelir; `degraded`, hizmet toparlanana kadar ücretli isteklerin reddedildiği anlamına gelir. Bu değer, herhangi bir zincirin düğüm durumundan bağımsızdır.
* `chains[]`: halka sunulan zincirler:
  * `chain`: zincir slug'ı (örneğin `robinhood_mainnet`).
  * `name`: insanlar tarafından okunabilir görünen ad.
  * `chain_id`: EIP-155 zincir kimliği (ondalık tamsayı).
  * `jsonrpc`: JSON-RPC'nin sunulup sunulmadığı.
  * `data`: Data API'nin sunulup sunulmadığı.
  * `data_features`: Bu zincir için kullanılabilir Data API yetenekleri (`data` `false` olduğunda boş bir dizi).
  * `data_status`: Data API çalışma durumu (`ok`, `syncing` veya `unavailable`; yalnızca `data` `true` olduğunda mevcuttur).
  * `status`: zincir düğüm durumu (`ok` veya `unavailable`).
  * `head`: en son blok bilgileri — `block` (en son blok yüksekliği), `time` (blok zaman damgası) ve `lag_seconds` (blok zamanının geçerli zamandan ne kadar geride kaldığı) — veya bilinmediğinde `null`.

Örnek yanıt:

```json
{
  "checked_at": "2026-09-28T12:00:00Z",
  "gateway": {
    "status": "ok"
  },
  "chains": [
    {
      "chain": "robinhood_mainnet", "name": "Robinhood Chain", "chain_id": 4663,
      "jsonrpc": true,
      "data": true,
      "data_features": [
        "blocks",
        "transactions",
        "address_transactions",
        "transfers",
        "token_metadata",
        "freshness"
      ],
      "status": "ok",
      "head": {
        "block": 73017329,
        "time": "2026-09-28T11:59:58Z",
        "lag_seconds": 2
      }
    }
  ]
}
```

### Zincir parametreleri (`GET /v1/chains`)

Her bir genel zincirin statik parametrelerini ve yöntem politikasını döndürür:

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

Yanıt alanları:

* `chains[]`: genel zincirler ve statik parametreleri:
  * `chain`: zincir slug'ı.
  * `name`: insanlar tarafından okunabilir görünen ad.
  * `chain_id`: EIP-155 zincir kimliği.
  * `jsonrpc`: JSON-RPC'nin sunulup sunulmadığı.
  * `data`: Data API'nin sunulup sunulmadığı.
  * `ws`: WebSocket bağlantılarının desteklenip desteklenmediği.
  * `subscriptions`: desteklenen WebSocket abonelik türleri (örneğin `newHeads`, `logs`).
  * `methods`: yöntem politikası:
    * `allow`: izin verilen yöntem adları (örneğin `eth_call`, `debug_traceTransaction`).
    * `deny`: reddedilen yöntemler veya ön ek joker karakter desenleri (örneğin `eth_newFilter`). Reddedilen yöntemler, izin verilenlere göre önceliklidir.
  * `max_logs_block_range`: tek bir `eth_getLogs` isteğinde izin verilen maksimum blok aralığı.
  * `state_window_blocks`: blok cinsinden geçmiş durum penceresi; tam geçmiş kullanılabilir olduğunda `null`.
  * `info`: zincir başına genel uzantı verileri (ayrılmıştır; şu anda boş bir nesne `{}`).
  * `public`: kimlik doğrulamasız genel uç nokta yapılandırması (veya `null`):
    * `url`: genel istekler için temel URL.
    * `methods`: genel uç noktada izin verilen yöntemler.
    * `rate_limit`: hız sınırları (`per_ip_rps`, `burst`, `batch_max`).
    * `history_blocks`: genel uç noktada erişilebilir blok geçmişi.
    * `send_raw_rate_limit`: `eth_sendRawTransaction` aracılığıyla işlemleri yayınlamak için hız sınırları.

Örnek yanıt:

```json
{
  "chains": [
    {
      "chain": "robinhood_mainnet", "name": "Robinhood Chain", "chain_id": 4663,
      "jsonrpc": true,
      "data": true,
      "ws": true,
      "subscriptions": [
        "newHeads",
        "logs"
      ],
      "methods": {
        "allow": [
          "eth_blockNumber",
          "eth_call",
          "eth_chainId",
          "debug_traceTransaction"
        ],
        "deny": [
          "eth_newFilter",
          "eth_newBlockFilter",
          "eth_newPendingTransactionFilter",
          "eth_getFilterLogs",
          "eth_getFilterChanges",
          "eth_uninstallFilter",
          "eth_subscribe",
          "eth_unsubscribe"
        ]
      },
      "max_logs_block_range": 1000,
      "state_window_blocks": 900,
      "info": {},
      "public": {
        "url": "https://api.blockvectra.com/v1/robinhood_mainnet/public",
        "methods": [
          "eth_chainId",
          "net_version",
          "eth_blockNumber",
          "eth_call"
        ],
        "rate_limit": {
          "per_ip_rps": 3,
          "burst": 20,
          "batch_max": 10
        },
        "history_blocks": 128,
        "send_raw_rate_limit": {
          "per_ip_rps": 1,
          "burst": 3
        }
      }
    }
  ]
}
```

### Planlar ve yöntem ağırlıkları (`GET /v1/plans`)

Plan parametreleri `GET https://console-api.blockvectra.com/v1/plans` adresinde sunulur. Bir agent, aktif ücretsiz plan sınırlarını ve her yöntemin Compute Unit (CU) ağırlığını okumak için bu uç noktayı çalışma zamanında sorgulayabilir:

* `free`: Ücretsiz Plan parametreleri — `signup_units` (birim cinsinden kayıt hibesi), `monthly_units` (birim cinsinden döngü yenileme eşiği), `window_days` (gün cinsinden kullanım döngüsü uzunluğu) ve `max_calls_per_sec` (ücretsiz plan saniye başına çağrı sınırı).
* `pricing`: ücretli plan parametreleri — `units_per_usd` (1 USD başına birim), `cu_per_unit` (birim başına CU) ve `min_topup_usd` (USD cinsinden minimum bakiye yükleme tutarı).
* `method_weights`: çağrı başına CU ağırlıkları, her biri `{ "method": string, "cu_weight": number }`. `method`, JSON-RPC yöntem adını veya desenini, listelenmemiş yöntemler için varsayılan ağırlıkları veya `data.<op>` gibi bir Data API işlemini belirtir. Ağırlıklar yöntem başınadır ve zincire göre bölünmez.

## 3. Kimlik doğrulama ve anahtar güvenliği

RPC çağrıları yapan agent'lar şu kurallara uymalıdır:

* **Kimlik doğrulama**: API key'i üç yoldan biriyle iletin. Yolda: `POST /v1/{chain}/{api_key}` — yol biçimi yalnızca yoldaki anahtarı kullanır ve her iki başlığı da yok sayar. `x-api-key` başlığında: `x-api-key: $BLOCKVECTRA_API_KEY` ile `POST /v1/{chain}`. `Authorization` başlığında: `Authorization: Bearer $BLOCKVECTRA_API_KEY` ile `POST /v1/{chain}`. Her iki başlık da mevcut olduğunda, boş olmayan bir `x-api-key` önceliklidir; Bearer yalnızca `x-api-key` eksik veya boş olduğunda kullanılır. Aynı anahtar desteklenen her zincirde ve Data API'de (anahtarı yalnızca `x-api-key` başlığında kabul eder) çalışır.
* **Anahtar güvenliği**: API key'lerini sunucu tarafı ortam değişkenlerinde (örneğin `BLOCKVECTRA_API_KEY`) veya bir gizli dizi yöneticisinde (secrets manager) saklayın. Bir anahtarı asla tarayıcı koduna veya herhangi bir istemci tarafı paketine gömmeyin. Uç noktalar `Access-Control-Allow-Origin: *` döndürür, ancak bunlar tarayıcıdan ziyade arka uç hizmetleri tarafından çağrılmak üzere tasarlanmıştır.
* **Ölçüm ve yükseltmeler**: kullanım Compute Units (CU) cinsinden ölçülür: her yöntem kendi ağırlığına göre CU tüketir; bakiye, CU havuzları ve ücretsiz plan hız sınırları tüm zincirler arasında paylaşılır. Ücretli bir bakiye yüklemesinden sonra, ücretsiz planın saniye başına çağrı sınırı artık geçerli olmaz; her anahtarın yine de bir CU hız sınırı ve burst kapasitesi vardır. Kullanılmayan ücretsiz krediler bakiyenizde kalır ve kullanılmaya devam edebilir. Ayrıntılar için [Fiyatlandırma sayfasına](https://blockvectra.com/tr/pricing/) bakın.

> **Henüz bir API key'iniz yok mu?**
>
> Bir Ethereum cüzdanınız varsa: Bir tarayıcı olmadan bir Ethereum cüzdan imzası kullanarak kaydolmak ve bir API key oluşturmak için [Programatik kayıt rehberini](https://docs.blockvectra.com/en/guides/programmatic-signup/) takip edin. Bir agent'ın kimliği cüzdanıdır: bir oturum belirteci veya anahtar kaybolursa, [kurtarmak için aynı cüzdanla yeniden kimlik doğrulaması yapın](https://docs.blockvectra.com/en/guides/programmatic-signup/#lost-your-session-or-api-key). Bir cüzdanınız yoksa: Kullanıcıdan [console.blockvectra.com](https://console.blockvectra.com/login/?next=%2Fkeys%2F) adresinde oturum açmasını, bir anahtar oluşturmasını ve bunu `BLOCKVECTRA_API_KEY` ortam değişkeni olarak ayarlamasını isteyin. Kullanıcıdan anahtarı sohbete yapıştırmasını istemeyin.


### Bakiyeyi sorgulayın (`GET /v1/account`)

Bir agent, Compute Units (CU) tüketmeden anahtarının mevcut bakiyesini, CU sınırlarını ve anahtar parametrelerini doğrudan kontrol edebilir. İstek biçimi, hız sınırları ve tam yanıt alanı tanımları için [Bakiyeyi sorgulama: GET /v1/account](https://docs.blockvectra.com/en/guides/billing-rules/#query-balance-get-v1account) bölümüne bakın.

## 4. Agent'lar için zincir seçimi iş akışı

Çağrıları göndermeden önce bir agent şu adımları izleyebilir:

1. **Zinciri ve yöntem politikasını kontrol edin**: `GET /v1/chains` çağrısı yapın, hedef zincirin var olduğunu ve `jsonrpc: true` değerine sahip olduğunu, ayrıca çağırmayı planladığınız yönteme `methods.allow` tarafından izin verildiğini ve `methods.deny` tarafından reddedilmediğini (reddetme önceliklidir) onaylayın.
2. **Canlı durumu kontrol edin**: `GET /v1/status` çağrısı yapın ve `gateway.status` değerinin `ok` olduğunu ve hedef zincirin `status` değerinin `ok` olduğunu onaylayın; zincir verilerinin kullanım senaryonuz için yeterince güncel olup olmadığına karar vermek için `head.lag_seconds` değerini kullanın. Bir zincirin düğümü senkronize olmadığında, `eth_chainId` dışındaki her yöntem `-32010` JSON-RPC hatası döndürür (HTTP 200, faturalandırılmaz), böylece agent bekleyip yeniden deneyebilir veya başka bir zincir seçebilir.
3. **İsteği gönderin**: `x-api-key` başlığı ve standart bir JSON-RPC gövdesi ile `POST /v1/{chain}`.

## 5. Minimum çalışan örnek

Aşağıdaki örnek, `eth_blockNumber` yöntemine izin veren bir zincir seçmek için `/v1/chains` dosyasını okur, `/v1/status` durumunu kontrol eder ve ardından bir kez `eth_blockNumber` çağırır.

**cURL**

```bash
export BLOCKVECTRA_API_KEY="rgw_your_api_key"

# 1. List public chains and their method policy
curl -s "https://api.blockvectra.com/v1/chains"

# 2. Check the service and per-chain status
curl -s "https://api.blockvectra.com/v1/status"

# 3. Call eth_blockNumber on the chain you selected (e.g. robinhood_mainnet)
curl -s "https://api.blockvectra.com/v1/robinhood_mainnet" \
  -H "x-api-key: $BLOCKVECTRA_API_KEY" \
  -H "x-bv-meter: 1" \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"eth_blockNumber","params":[]}'
```


  **TypeScript**

```typescript
const apiKey = process.env.BLOCKVECTRA_API_KEY;

if (!apiKey) {
  throw new Error("Missing BLOCKVECTRA_API_KEY");
}

type ChainFacts = {
  chain: string;
  jsonrpc: boolean;
  methods: { allow: string[]; deny: string[] };
};

function matches(pattern: string, method: string): boolean {
  if (pattern === "*") return true;
  if (pattern.endsWith("*")) return method.startsWith(pattern.slice(0, -1));
  return pattern === method;
}

// 1. Fetch the public chain directory
const chainsRes = await fetch("https://api.blockvectra.com/v1/chains");
const { chains } = (await chainsRes.json()) as { chains: ChainFacts[] };

// 2. Select a chain that serves JSON-RPC and allows eth_blockNumber
const selected = chains.find(
  (chain) =>
    chain.jsonrpc &&
    !chain.methods.deny.some((pattern) => matches(pattern, "eth_blockNumber")) &&
    chain.methods.allow.some((pattern) => matches(pattern, "eth_blockNumber")),
);

if (!selected) {
  throw new Error("No chain found that allows eth_blockNumber");
}

// 3. Confirm the service and the selected chain are ready
const statusRes = await fetch("https://api.blockvectra.com/v1/status");
const status = await statusRes.json();
const chainStatus = status.chains?.find(
  (chain: { chain: string }) => chain.chain === selected.chain,
);

if (status.gateway?.status !== "ok" || chainStatus?.status !== "ok") {
  throw new Error(`Chain ${selected.chain} is currently unavailable`);
}

// 4. Call eth_blockNumber on the selected chain
const defaultEndpoint = "https://api.blockvectra.com/v1/robinhood_mainnet";
const rpcUrl = `${defaultEndpoint.slice(0, defaultEndpoint.lastIndexOf("/"))}/${selected.chain}`;
const rpcRes = await fetch(rpcUrl, {
  method: "POST",
  headers: {
    "Content-Type": "application/json",
    "x-api-key": apiKey,
    "x-bv-meter": "1",
  },
  body: JSON.stringify({
    jsonrpc: "2.0",
    id: 1,
    method: "eth_blockNumber",
    params: [],
  }),
});

console.log("Response:", await rpcRes.json());
```


  **Python**

```python
import os
import requests

api_key = os.environ["BLOCKVECTRA_API_KEY"]


def matches(pattern: str, method: str) -> bool:
    if pattern == "*":
        return True
    if pattern.endsWith("*"):
        return method.startswith(pattern[:-1])
    return pattern == method


# 1. Fetch the public chain directory
chains = requests.get("https://api.blockvectra.com/v1/chains").json()["chains"]

# 2. Select a chain that serves JSON-RPC and allows eth_blockNumber
selected = next(
    (
        chain
        for chain in chains
        if chain["jsonrpc"]
        and not any(matches(p, "eth_blockNumber") for p in chain["methods"]["deny"])
        and any(matches(p, "eth_blockNumber") for p in chain["methods"]["allow"])
    ),
    None,
)

if selected is None:
    raise RuntimeError("No chain found that allows eth_blockNumber")

# 3. Confirm the service and the selected chain are ready
status = requests.get("https://api.blockvectra.com/v1/status").json()
chain_status = next(
    (c for c in status["chains"] if c["chain"] == selected["chain"]),
    None,
)

if (
    status["gateway"]["status"] != "ok"
    or chain_status is None
    or chain_status["status"] != "ok"
):
    raise RuntimeError(f"Chain {selected['chain']} is currently unavailable")

# 4. Call eth_blockNumber on the selected chain
default_endpoint = "https://api.blockvectra.com/v1/robinhood_mainnet"
rpc_url = f"{default_endpoint.rsplit('/', 1)[0]}/{selected['chain']}"
rpc_response = requests.post(
    rpc_url,
    headers={
        "Content-Type": "application/json",
        "x-api-key": api_key,
        "x-bv-meter": "1",
    },
    json={"jsonrpc": "2.0", "id": 1, "method": "eth_blockNumber", "params": []},
).json()

print("Response:", rpc_response)
```


Başarılı bir çağrı standart bir JSON-RPC yanıt nesnesi döndürür:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "0x45a27f1"
}
```

Yanıt başlıklarında istek başına CU ücretlerini ve kalan bakiye birimlerini incelemek için `x-bv-meter: 1` başlığını ekleyin. Başlık davranışı ve hata durumları için [Ücretlendirme ve bakiye yanıt başlıkları](https://docs.blockvectra.com/en/guides/billing-rules/#http-status-codes-and-billing-rules) bölümüne bakın.

## Sonraki adımlar

* BlockVectra'nın indekslediği her veri kümesini görmek için [veri kümeleri dizinine göz atın](https://blockvectra.com/tr/data/).
* Hesabınızın neleri içerdiğini kontrol etmek için [ücretsiz planı ve fiyatlandırmayı inceleyin](https://blockvectra.com/tr/pricing/#free).
* Cüzdan imzasıyla kaydolmak ve bir API key oluşturmak için [programatik kayıt rehberini takip edin](https://docs.blockvectra.com/en/guides/programmatic-signup/) veya bir anahtar oluşturmak için [konsolda oturum açın](https://console.blockvectra.com/login/?next=%2Fkeys%2F).