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

# Tarifler

> OrbitFlare üzerinde çoğu kişinin ilk geliştirdiği şeyler için eksiksiz, çalıştırılabilir programlar: anahtarı kontrol etme, bir hesabı izleme, bir işlemi bekleme, bir programın akışını alma ve cüzdan geçmişini okuma. TypeScript, Rust, Go ve curl.

Bu sayfadaki her program eksiksizdir. Bir dosyaya kopyalayın, anahtarınızı ayarlayın ve çalıştırın. Her biri yayımlanmadan önce gerçek OrbitFlare uç noktalarına karşı çalıştırıldı.

## Başlamadan önce

Lisans anahtarınızı bir kez ayarlayın. Üç SDK da anahtarı ortam değişkeninden okur, bu yüzden kodunuzda hiç yer alması gerekmez.

```bash theme={"theme":{"light":"github-light","dark":"github-dark-default"}}
export ORBITFLARE_LICENSE_KEY=ORBIT-XXXXXX-NNNNNN-NNNNNN
```

Örnekler Frankfurt (`fra`) kullanır. Ana bilgisayarı sunucularınıza en yakın [bölgeyle](/tr/infrastructure) değiştirin. Lisansınız [API Key Only modundaysa](/tr/authentication#kimlik-doğrulama-modları), SDK'lar anahtarı Jetstream ve Yellowstone'a da gönderir. IP Whitelist modunda, akış tarifini çalıştırmadan önce sunucunuzun IP'sini [panelden](https://orbitflare.com/dashboard) lisansa ekleyin.

**TypeScript**

```bash theme={"theme":{"light":"github-light","dark":"github-dark-default"}}
npm init -y && npm pkg set type=module
npm install @orbitflare/sdk ws @grpc/grpc-js yaml bs58
```

`ws` ve `@grpc/grpc-js`, SDK'nın isteğe bağlı eş bağımlılıklarıdır. Bunlar olmadan WebSocket ve Jetstream istemcileri `Cannot find package 'ws'` veya `Cannot find package '@grpc/grpc-js'` hatasıyla başarısız olur. Bir dosyayı `npx tsx file.ts` ile çalıştırın.

**Rust**

```toml Cargo.toml theme={"theme":{"light":"github-light","dark":"github-dark-default"}}
[package]
name = "recipes"
version = "0.1.0"
edition = "2024"

[dependencies]
orbitflare-sdk = { version = "0.4", features = ["ws", "jetstream"] }
tokio = { version = "1", features = ["full"] }
serde_json = "1"
bs58 = "0.5"
```

Her programı `examples/` altına kaydedin ve `cargo run --example name` ile çalıştırın.

**Go**

```bash theme={"theme":{"light":"github-light","dark":"github-dark-default"}}
go mod init recipes
go get github.com/orbitflare/orbitflare-sdk-go@latest github.com/mr-tron/base58
```

Her programı `main.go` içeren kendi klasörüne koyun ve `go run ./folder` ile çalıştırın.

## Anahtarınızın çalıştığını kontrol edin

Kurulum sorunlarını elemenin en hızlı yolu. Bu bir slot numarası yazdırıyorsa anahtarınız, bölgeniz ve ağ yolunuz sorunsuzdur.

```bash curl theme={"theme":{"light":"github-light","dark":"github-dark-default"}}
curl -s https://fra.rpc.orbitflare.com \
  -H "x-api-key: $ORBITFLARE_LICENSE_KEY" \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"getSlot"}'
```

```ts TypeScript theme={"theme":{"light":"github-light","dark":"github-dark-default"}}
import { RpcClientBuilder } from '@orbitflare/sdk';

// The key comes from ORBITFLARE_LICENSE_KEY, so it never has to appear in code.
const rpc = new RpcClientBuilder().url('https://fra.rpc.orbitflare.com').build();

// A slot number back means the key, region and network path all work.
console.log('slot:', await rpc.getSlot());
```

```rust Rust theme={"theme":{"light":"github-light","dark":"github-dark-default"}}
use orbitflare_sdk::RpcClientBuilder;

#[tokio::main]
async fn main() -> orbitflare_sdk::Result<()> {
    // The key comes from ORBITFLARE_LICENSE_KEY, so it never has to appear in code.
    let rpc = RpcClientBuilder::new()
        .url("https://fra.rpc.orbitflare.com")
        .build()?;

    // A slot number back means the key, region and network path all work.
    println!("slot: {}", rpc.get_slot().await?);
    Ok(())
}
```

```go Go theme={"theme":{"light":"github-light","dark":"github-dark-default"}}
package main

import (
	"context"
	"fmt"
	"log"

	"github.com/orbitflare/orbitflare-sdk-go/rpc"
)

func main() {
	// The key comes from ORBITFLARE_LICENSE_KEY, so it never has to appear in code.
	client, err := rpc.NewBuilder().URL("https://fra.rpc.orbitflare.com").Build()
	if err != nil {
		log.Fatal(err)
	}

	// A slot number back means the key, region and network path all work.
	slot, err := client.GetSlot(context.Background())
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println("slot:", slot)
}
```

Başarısız olursa hata nedenini söyler:

| Yanıt | Anlamı |
| - | - |
| `-32401 missing API key` (HTTP 401) | Anahtar gönderilmedi. `x-api-key` başlığını veya `?api_key=` parametresini ya da `ORBITFLARE_LICENSE_KEY` değişkeninin aynı kabukta export edildiğini kontrol edin |
| `-32402 invalid API key` (HTTP 403) | Anahtar yanlış ya da yeniden oluşturuldu. Panelden tekrar kopyalayın |
| `-32404 IP not whitelisted` (HTTP 403) | Bu makinenin IP'sine veya bu bölgeye lisansınızda izin verilmiyor. IP'yi panelden ekleyin veya lisansınızın kapsadığı bir bölgeyi deneyin |

Tam liste [hata referansında](/tr/rpc/error-codes) bulunur.

## Bir hesaptaki değişiklikleri izleyin

WebSocket üzerinden abone olur ve her güncellemeyi yazdırır. Örnek, her slotta değiştiği için Clock sysvar'ını izler, böylece çıktıyı hemen görürsünüz. Yerine herhangi bir hesap adresi koyabilirsiniz.

```bash wscat theme={"theme":{"light":"github-light","dark":"github-dark-default"}}
wscat -c "wss://fra.rpc.orbitflare.com?api_key=$ORBITFLARE_LICENSE_KEY"
> {"jsonrpc":"2.0","id":1,"method":"accountSubscribe","params":["SysvarC1ock11111111111111111111111111111111",{"encoding":"base64","commitment":"confirmed"}]}
```

```ts TypeScript theme={"theme":{"light":"github-light","dark":"github-dark-default"}}
import { WsClientBuilder } from '@orbitflare/sdk/ws';

// The SDK pings every 10 s and resubscribes on its own after a reconnect.
const ws = await new WsClientBuilder().url('wss://fra.rpc.orbitflare.com').build();

// Notifies only when the account changes. The Clock sysvar changes every slot.
const sub = await ws.accountSubscribe('SysvarC1ock11111111111111111111111111111111', 'confirmed');

for (let account = await sub.next(); account !== undefined; account = await sub.next()) {
  // Clock layout: the first 8 bytes are the current slot as a little-endian u64.
  const data = Buffer.from(account.data[0], 'base64');
  console.log(`clock slot ${data.readBigUInt64LE(0)}, ${account.lamports} lamports`);
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"github-dark-default"}}
use orbitflare_sdk::WsClientBuilder;

#[tokio::main]
async fn main() -> orbitflare_sdk::Result<()> {
    // The SDK pings every 10 s and resubscribes on its own after a reconnect.
    let ws = WsClientBuilder::new()
        .url("wss://fra.rpc.orbitflare.com")
        .build()
        .await?;

    // Notifies only when the account changes. The Clock sysvar changes every slot.
    let mut sub = ws
        .account_subscribe("SysvarC1ock11111111111111111111111111111111", "confirmed")
        .await?;

    // Each update is the account's full new state: lamports, owner and base64 data.
    while let Some(account) = sub.next().await {
        println!(
            "{} lamports, data {}",
            account["lamports"], account["data"][0]
        );
    }
    Ok(())
}
```

```go Go theme={"theme":{"light":"github-light","dark":"github-dark-default"}}
package main

import (
	"context"
	"fmt"
	"log"

	"github.com/orbitflare/orbitflare-sdk-go/ws"
)

func main() {
	ctx := context.Background()

	// The SDK pings every 10 s and resubscribes on its own after a reconnect.
	client, err := ws.NewBuilder().URL("wss://fra.rpc.orbitflare.com").Build(ctx)
	if err != nil {
		log.Fatal(err)
	}
	defer client.Close()

	// Notifies only when the account changes. The Clock sysvar changes every slot.
	sub, err := client.AccountSubscribe(ctx, "SysvarC1ock11111111111111111111111111111111", "confirmed")
	if err != nil {
		log.Fatal(err)
	}
	defer sub.Unsubscribe()

	// Each update is the account's full new state: lamports, owner and base64 data.
	for {
		account, ok := sub.Next(ctx)
		if !ok {
			return
		}
		fmt.Println(string(account))
	}
}
```

Güncellemeler yalnızca hesap değiştiğinde gelir. Sessiz bir hesap, bozuk değil sessiz bir abonelik demektir. Hiçbir şey gelmiyorsa [WebSocket hata ayıklama](/tr/troubleshooting/websocket) sayfasına bakın.

## Bir işlemin onaylanmasını bekleyin

Komut satırında bir imza verin. Program, işlem onaylanana, başarısız olana veya gelmeyeceği belli olana kadar `getSignatureStatuses` ile yoklama yapar.

```bash curl theme={"theme":{"light":"github-light","dark":"github-dark-default"}}
curl -s https://fra.rpc.orbitflare.com \
  -H "x-api-key: $ORBITFLARE_LICENSE_KEY" \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"getSignatureStatuses","params":[["SIGNATURE"],{"searchTransactionHistory":true}]}'
```

```ts TypeScript theme={"theme":{"light":"github-light","dark":"github-dark-default"}}
import { RpcClientBuilder } from '@orbitflare/sdk';

const signature = process.argv[2];
const rpc = new RpcClientBuilder().url('https://fra.rpc.orbitflare.com').build();

// 120 polls 500 ms apart is 60 s, well past the ~30 s a blockhash stays valid.
for (let attempt = 0; attempt < 120; attempt++) {
  // searchTransactionHistory also finds signatures older than the node's recent status cache.
  const { value } = await rpc.request('getSignatureStatuses', [
    [signature],
    { searchTransactionHistory: true },
  ]);
  const status = value[0];
  // err set means it landed and failed. The fee was still charged.
  if (status?.err) {
    console.log('landed but failed:', JSON.stringify(status.err));
    process.exit(1);
  }
  if (status?.confirmationStatus === 'confirmed' || status?.confirmationStatus === 'finalized') {
    console.log(`${status.confirmationStatus} in slot ${status.slot}`);
    process.exit(0);
  }
  // null means the cluster has not seen it yet, so keep polling.
  await new Promise((r) => setTimeout(r, 500));
}
console.log('not found after 60s: the transaction was dropped or its blockhash expired');
```

```rust Rust theme={"theme":{"light":"github-light","dark":"github-dark-default"}}
use std::time::Duration;

use orbitflare_sdk::RpcClientBuilder;
use serde_json::json;

#[tokio::main]
async fn main() -> orbitflare_sdk::Result<()> {
    let signature = std::env::args()
        .nth(1)
        .expect("usage: wait_for_signature <SIGNATURE>");
    let rpc = RpcClientBuilder::new()
        .url("https://fra.rpc.orbitflare.com")
        .build()?;

    // 120 polls 500 ms apart is 60 s, well past the ~30 s a blockhash stays valid.
    for _ in 0..120 {
        // searchTransactionHistory also finds signatures older than the node's recent status cache.
        let res = rpc
            .request(
                "getSignatureStatuses",
                json!([[signature], {"searchTransactionHistory": true}]),
            )
            .await?;
        let status = &res["value"][0];
        // err set means it landed and failed. The fee was still charged.
        if !status["err"].is_null() {
            println!("landed but failed: {}", status["err"]);
            std::process::exit(1);
        }
        if let Some(level @ ("confirmed" | "finalized")) = status["confirmationStatus"].as_str() {
            println!("{level} in slot {}", status["slot"]);
            return Ok(());
        }
        // null means the cluster has not seen it yet, so keep polling.
        tokio::time::sleep(Duration::from_millis(500)).await;
    }
    println!("not found after 60s: the transaction was dropped or its blockhash expired");
    Ok(())
}
```

```go Go theme={"theme":{"light":"github-light","dark":"github-dark-default"}}
package main

import (
	"context"
	"encoding/json"
	"fmt"
	"log"
	"os"
	"time"

	"github.com/orbitflare/orbitflare-sdk-go/rpc"
)

type statuses struct {
	Value []*struct {
		Slot               uint64          `json:"slot"`
		Err                json.RawMessage `json:"err"`
		ConfirmationStatus string          `json:"confirmationStatus"`
	} `json:"value"`
}

func main() {
	signature := os.Args[1]
	client, err := rpc.NewBuilder().URL("https://fra.rpc.orbitflare.com").Build()
	if err != nil {
		log.Fatal(err)
	}

	// 120 polls 500 ms apart is 60 s, well past the ~30 s a blockhash stays valid.
	for range 120 {
		// searchTransactionHistory also finds signatures older than the node's recent status cache.
		raw, err := client.Request(context.Background(), "getSignatureStatuses",
			[]any{[]string{signature}, map[string]bool{"searchTransactionHistory": true}})
		if err != nil {
			log.Fatal(err)
		}
		var res statuses
		if err := json.Unmarshal(raw, &res); err != nil {
			log.Fatal(err)
		}
		if s := res.Value[0]; s != nil {
			// err set means it landed and failed. The fee was still charged.
			if string(s.Err) != "null" && len(s.Err) > 0 {
				fmt.Println("landed but failed:", string(s.Err))
				os.Exit(1)
			}
			if s.ConfirmationStatus == "confirmed" || s.ConfirmationStatus == "finalized" {
				fmt.Printf("%s in slot %d\n", s.ConfirmationStatus, s.Slot)
				return
			}
		}
		// null means the cluster has not seen it yet, so keep polling.
		time.Sleep(500 * time.Millisecond)
	}
	fmt.Println("not found after 60s: the transaction was dropped or its blockhash expired")
}
```

`searchTransactionHistory` ile yoklama eski ya da yeni her imza için çalışır. `signatureSubscribe` yalnızca yakın tarihli işlemleri bilir, bu yüzden birkaç dakika önce onaylanmış bir işleme abone olmak hiçbir zaman bildirim üretmez. `null` durumu, kümenin işlemi görmediği anlamına gelir. Bu durumda ne yapılacağı [İşlem hata ayıklama](/tr/troubleshooting/transactions) sayfasında anlatılır.

## Bir programın işlemlerini akışla alın

Jetstream v2 kullanarak pump.fun'a dokunan her işlemi, zenginleştirme alanlarından gelen ücret ödeyici ve compute unit fiyatıyla birlikte yazdırır.

```bash grpcurl theme={"theme":{"light":"github-light","dark":"github-dark-default"}}
grpcurl -plaintext -import-path . -proto jetstream_v2.proto \
  -d '{"add_filters":{"filters":[{"filter_id":"pump","filter":{"account_include":["6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P"],"include_enrichment":true}}]}}' \
  fra.jetstream.orbitflare.com:80 jetstream.v2.JetstreamV2/SubscribeTransactions
```

```ts TypeScript theme={"theme":{"light":"github-light","dark":"github-dark-default"}}
import bs58 from 'bs58';
import { JetstreamClientBuilder, TransactionFilter } from '@orbitflare/sdk/jetstream/v2';

const PUMP_FUN = '6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P';

// In API Key Only mode the SDK sends ORBITFLARE_LICENSE_KEY as x-token.
const jetstream = new JetstreamClientBuilder().url('http://fra.jetstream.orbitflare.com').build();

// Matches every transaction that mentions pump.fun. Enrichment adds the fee payer and CU price.
const filter = new TransactionFilter().accountInclude([PUMP_FUN]).includeEnrichment(true).withId('pump');

for await (const update of jetstream.subscribeTransactions([filter])) {
  // Other updates are filter validations, heartbeats and pongs.
  const tx = update.transaction?.transaction;
  if (!tx) continue;
  // compute_unit_price is micro-lamports per CU, not the total priority fee.
  console.log(
    `${tx.slot} ${bs58.encode(tx.signature)} payer=${bs58.encode(tx.feePayer)} cu_price=${tx.computeUnitPrice}`,
  );
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"github-dark-default"}}
use orbitflare_sdk::jetstream::v2::{JetstreamClientBuilder, TransactionFilter};
use orbitflare_sdk::proto::jetstream::v2::subscribe_transactions_response::Payload;

const PUMP_FUN: &str = "6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P";

#[tokio::main]
async fn main() -> orbitflare_sdk::Result<()> {
    // In API Key Only mode the SDK sends ORBITFLARE_LICENSE_KEY as x-token.
    let jetstream = JetstreamClientBuilder::new()
        .url("http://fra.jetstream.orbitflare.com")
        .build()?;

    // Matches every transaction that mentions pump.fun. Enrichment adds the fee payer and CU price.
    let filter = TransactionFilter::new()
        .account_include([PUMP_FUN])
        .include_enrichment(true)
        .with_id("pump");

    let mut stream = jetstream.subscribe_transactions(vec![filter]);

    while let Some(update) = stream.next().await {
        // Other updates are filter validations, heartbeats and pongs.
        if let Some(Payload::Transaction(ft)) = update?.payload
            && let Some(tx) = ft.transaction
        {
            // compute_unit_price is micro-lamports per CU, not the total priority fee.
            println!(
                "{} {} payer={} cu_price={}",
                tx.slot,
                bs58::encode(&tx.signature).into_string(),
                bs58::encode(&tx.fee_payer).into_string(),
                tx.compute_unit_price
            );
        }
    }
    Ok(())
}
```

```go Go theme={"theme":{"light":"github-light","dark":"github-dark-default"}}
package main

import (
	"context"
	"fmt"
	"log"

	"github.com/mr-tron/base58"
	jetstreamv2 "github.com/orbitflare/orbitflare-sdk-go/jetstream/v2"
)

const pumpFun = "6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P"

func main() {
	// In API Key Only mode the SDK sends ORBITFLARE_LICENSE_KEY as x-token.
	client, err := jetstreamv2.NewBuilder().URL("http://fra.jetstream.orbitflare.com").Build()
	if err != nil {
		log.Fatal(err)
	}
	defer client.Close()

	// Matches every transaction that mentions pump.fun. Enrichment adds the fee payer and CU price.
	filter := jetstreamv2.NewTransactionFilter().
		AccountInclude(pumpFun).
		IncludeEnrichment(true).
		WithID("pump")

	stream := client.SubscribeTransactions(filter)
	defer stream.Close()

	for {
		update, err := stream.Next(context.Background())
		if err != nil {
			log.Fatal(err)
		}
		// Other updates are filter validations, heartbeats and pongs.
		tx := update.GetTransaction().GetTransaction()
		if tx == nil {
			continue
		}
		// compute_unit_price is micro-lamports per CU, not the total priority fee.
		fmt.Printf("%d %s payer=%s cu_price=%d\n",
			tx.GetSlot(),
			base58.Encode(tx.GetSignature()),
			base58.Encode(tx.GetFeePayer()),
			tx.GetComputeUnitPrice())
	}
}
```

`grpcurl` sürümü, [SDK deposundaki](https://github.com/orbitflare/orbitflare-sdk-ts/tree/main/protos) `jetstream_v2.proto` dosyasının geçerli klasörde olmasını gerektirir. Jetstream yalnızca işlemleri filtreler. Hesap durumunu izlemek için [Yellowstone](/tr/data-streaming/yellowstone-account-monitoring) kullanın.

## Bir cüzdanın son işlemlerini okuyun

`getTransactionsForAddress` kullanarak bir adresin en son 10 işlemini döndürür.

```bash curl theme={"theme":{"light":"github-light","dark":"github-dark-default"}}
curl -s https://fra.rpc.orbitflare.com \
  -H "x-api-key: $ORBITFLARE_LICENSE_KEY" \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"getTransactionsForAddress","params":["WALLET",{"limit":10}]}'
```

```ts TypeScript theme={"theme":{"light":"github-light","dark":"github-dark-default"}}
import { RpcClientBuilder } from '@orbitflare/sdk';

type Entry = { signature: string; slot: number; blockTime: number; err: unknown };

const wallet = process.argv[2];
const rpc = new RpcClientBuilder().url('https://fra.rpc.orbitflare.com').build();

// Returns signatures by default. Ask for "full" with maxSupportedTransactionVersion 1 to get bodies.
const { data } = await rpc.getTransactionsForAddress(wallet, { limit: 10 });

// Newest first. Pass paginationToken from the response to get the next page.
for (const tx of data as Entry[]) {
  const when = new Date(tx.blockTime * 1000).toISOString();
  console.log(when, tx.slot, tx.signature, tx.err ? 'failed' : 'ok');
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"github-dark-default"}}
use orbitflare_sdk::{GetTransactionsOptions, RpcClientBuilder};

#[tokio::main]
async fn main() -> orbitflare_sdk::Result<()> {
    let wallet = std::env::args().nth(1).expect("usage: history <WALLET>");
    let rpc = RpcClientBuilder::new()
        .url("https://fra.rpc.orbitflare.com")
        .build()?;

    let options = GetTransactionsOptions {
        limit: Some(10),
        ..Default::default()
    };
    // Returns signatures by default. Ask for "full" with maxSupportedTransactionVersion 1 to get bodies.
    let page = rpc.get_transactions_for_address(&wallet, options).await?;

    // Newest first. Pass paginationToken from the response to get the next page.
    for tx in page.data {
        let status = if tx["err"].is_null() { "ok" } else { "failed" };
        println!(
            "{} {} {}",
            tx["slot"],
            tx["signature"].as_str().unwrap_or(""),
            status
        );
    }
    Ok(())
}
```

```go Go theme={"theme":{"light":"github-light","dark":"github-dark-default"}}
package main

import (
	"context"
	"encoding/json"
	"fmt"
	"log"
	"os"

	"github.com/orbitflare/orbitflare-sdk-go/rpc"
)

type entry struct {
	Signature string          `json:"signature"`
	Slot      uint64          `json:"slot"`
	Err       json.RawMessage `json:"err"`
}

func main() {
	wallet := os.Args[1]
	client, err := rpc.NewBuilder().URL("https://fra.rpc.orbitflare.com").Build()
	if err != nil {
		log.Fatal(err)
	}

	limit := uint32(10)
	// Returns signatures by default. Ask for "full" with maxSupportedTransactionVersion 1 to get bodies.
	page, err := client.GetTransactionsForAddress(context.Background(), wallet, &rpc.GetTransactionsOptions{Limit: &limit})
	if err != nil {
		log.Fatal(err)
	}

	// Newest first. Pass paginationToken from the response to get the next page.
	for _, raw := range page.Data {
		var tx entry
		if err := json.Unmarshal(raw, &tx); err != nil {
			log.Fatal(err)
		}
		status := "ok"
		if string(tx.Err) != "null" {
			status = "failed"
		}
		fmt.Println(tx.Slot, tx.Signature, status)
	}
}
```

Her girdide `signature`, `slot`, `blockTime`, `err` ve `confirmationStatus` bulunur. Sonraki sayfayı almak için dönen `paginationToken` değerini gönderin. İşlemlerin tamamı için `transactionDetails` değerini `"maxSupportedTransactionVersion": 1` ile birlikte `"full"` olarak ayarlayın. Bu parametre olmadan sürüm 1 işlemler sessizce dışarıda bırakılır. Filtreler ve sıralama için [getTransactionsForAddress](/tr/fetching-data/getTransactionsForAddress) sayfasına bakın.

## Daha fazla örnek

> **[Hata referansı](/tr/rpc/error-codes)**
>
> OrbitFlare'in döndürdüğü her hata ve ne yapılması gerektiği.

> **[İşlem hata ayıklama](/tr/troubleshooting/transactions)**
>
> Bir işlemin neden başarısız olduğu, düşürüldüğü veya hiç zincire girmediği.

> **[Apex ile gönderme](/tr/apex/quickstart)**
>
> OrbitFlare Apex ile işlemleri daha hızlı zincire ulaştırın.

> **[SDK referansı](/tr/sdk/overview)**
>
> SDK'lardaki her istemci, builder seçeneği ve metot.


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