go get github.com/orbvpn/sdk-go@latest

pip install orbvpn

npm install @orbvpn/sdk
# or
yarn add @orbvpn/sdk
# or
pnpm add @orbvpn/sdk

dependencies: [
    .package(url: "https://github.com/orbvpn/sdk-swift.git", from: "1.0.0")
]

dependencies {
    implementation("com.orbvpn:sdk-kotlin:1.0.0")
}

package main

import (
    "context"
    "fmt"
    "log"

    orbvpn "github.com/orbvpn/sdk-go"
)

func main() {
    // Initialize client with automatic token management
    client, err := orbvpn.NewClient(
        orbvpn.WithCredentials("user@example.com", "your_password"),
        orbvpn.WithBaseURL("https://api.orbai.world"),
        orbvpn.WithRetry(3, 500), // 3 retries, 500ms base delay
    )
    if err != nil {
        log.Fatal(err)
    }
    defer client.Close()

    ctx := context.Background()

    // Get current user profile
    user, err := client.Users.Me(ctx)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("Logged in as: %s\n", user.Email)

    // List available VPN servers
    servers, err := client.Servers.List(ctx, &orbvpn.ServerListParams{
        Country: "US",
        Limit:   10,
    })
    if err != nil {
        log.Fatal(err)
    }

    for _, s := range servers.Data {
        fmt.Printf("Server: %s (%s) - Load: %d%%\n", s.Name, s.City, s.Load)
    }

    // Stream real-time metrics via gRPC
    stream, err := client.GRPC.OrbMesh.StreamMetrics(ctx, &orbvpn.MetricsRequest{
        NodeID:   "node_abc123",
        Interval: 5, // seconds
    })
    if err != nil {
        log.Fatal(err)
    }

    for {
        metrics, err := stream.Recv()
        if err != nil {
            break
        }
        fmt.Printf("CPU: %.1f%% | Memory: %.1f%% | Connections: %d\n",
            metrics.CpuUsage, metrics.MemoryUsage, metrics.ActiveConnections)
    }
}

import asyncio
from orbvpn import OrbVPNClient, ServerListParams

async def main():
    # Initialize client with automatic token management
    client = OrbVPNClient(
        email="user@example.com",
        password="your_password",
        base_url="https://api.orbai.world",
        max_retries=3,
    )

    async with client:
        # Get current user profile
        user = await client.users.me()
        print(f"Logged in as: {user.email}")

        # List available VPN servers
        servers = await client.servers.list(
            ServerListParams(country="US", limit=10)
        )
        for server in servers.data:
            print(f"Server: {server.name} ({server.city}) - Load: {server.load}%")

        # Check a threat indicator via OrbGuard
        result = await client.orbguard.intelligence.check(
            indicator="suspicious-domain.com",
            indicator_type="domain",
        )
        print(f"Threat score: {result.score}/100")
        print(f"Categories: {', '.join(result.categories)}")

        # Subscribe to real-time notifications
        async for event in client.ws.notifications.subscribe():
            print(f"[{event.type}] {event.message}")

asyncio.run(main())

import { OrbVPNClient } from '@orbvpn/sdk';

const client = new OrbVPNClient({
  email: 'user@example.com',
  password: 'your_password',
  baseURL: 'https://api.orbai.world',
  maxRetries: 3,
});

async function main() {
  // Get current user profile
  const user = await client.users.me();
  console.log(`Logged in as: ${user.email}`);

  // List available VPN servers
  const servers = await client.servers.list({
    country: 'US',
    limit: 10,
  });

  for (const server of servers.data) {
    console.log(`Server: ${server.name} (${server.city}) - Load: ${server.load}%`);
  }

  // Check a threat indicator via OrbGuard
  const threat = await client.orbguard.intelligence.check({
    indicator: 'suspicious-domain.com',
    indicatorType: 'domain',
  });
  console.log(`Threat score: ${threat.score}/100`);

  // Subscribe to real-time notifications via WebSocket
  const ws = client.ws.notifications.subscribe();
  ws.on('notification', (event) => {
    console.log(`[${event.type}] ${event.message}`);
  });
  ws.on('device_status', (event) => {
    console.log(`Device ${event.deviceId}: ${event.status}`);
  });
}

main().catch(console.error);