pip install devotel-orbit-sdk
export ORBIT_API_KEY=dv_test_sk_your_key_here

from orbit_sdk import OrbitClient, OrbitError

client = OrbitClient.from_env()

try:
    result = client.messages.send_sms(
        to="+14155552671",
        body="Hello from Orbit!",
    )
    print("queued:", result["data"]["id"])
except OrbitError as exc:
    print("send failed:", exc.code, exc.message)

# Escape hatch — POST a route the wrapper hasn't typed yet:
result = client.request(
    "POST",
    "/api/v1/voice/conferences",
    json_body={"name": "support-room-42"},
)
print(result["data"]["id"])

# Not yet on a public module proxy — go get the workspace module path:
#   go get github.com/devotel/orbit-go
export ORBIT_API_KEY=dv_test_sk_your_key_here

// go.mod: require github.com/devotel/orbit-go (module path, not yet on a public proxy)
package main

import (
	"context"
	"fmt"
	"os"
	"time"

	"github.com/devotel/orbit-go/orbit"
)

func main() {
	client, err := orbit.NewClient(os.Getenv("ORBIT_API_KEY"))
	if err != nil {
		panic(err)
	}

	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
	defer cancel()

	resp, err := client.Messages().SendSMS(ctx, orbit.SendSMSInput{
		To:   "+14155552671",
		Body: "Hello from Orbit!",
	})
	if err != nil {
		panic(err)
	}
	fmt.Println("queued:", resp.Data.ID)
}

// Escape hatch — out-of-scope surfaces call Request directly:
var conf struct {
	Data struct {
		ID string `json:"id"`
	} `json:"data"`
}
err = client.Request(
	ctx,
	"POST",
	"/voice/conferences",
	nil,
	map[string]interface{}{"name": "support-room-42"},
	&conf,
	"",
)

# Not yet on RubyGems — add the workspace path to your Gemfile:
#   gem "orbit_sdk", path: "packages/sdk-ruby"
export ORBIT_API_KEY=dv_test_sk_your_key_here

require "orbit_sdk"

client = OrbitSdk::Client.from_env
begin
  result = client.messages.send_sms(
    to: "+14155552671",
    body: "Hello from Orbit!",
  )
  puts "queued: #{result.dig("data", "id")}"
rescue OrbitSdk::OrbitError => e
  warn "send failed: #{e.code} — #{e.message}"
end

# Escape hatch — out-of-scope surfaces call request directly:
conf = client.request(
  "POST",
  "/voice/conferences",
  json_body: { "name" => "support-room-42" },
)
puts conf.dig("data", "id")

# Not yet on Packagist — vendor the SDK from the monorepo or call the
# REST API directly. Setup lives on the PHP SDK page:
#   https://orbit.devotel.io/sdks/php
export ORBIT_API_KEY=dv_test_sk_your_key_here

<?php
use Devotel\Orbit\Errors\OrbitError;
use Devotel\Orbit\OrbitClient;

try {
    $client = OrbitClient::fromEnv();
    $result = $client->messages->sendSms(
        to: '+14155552671',
        body: 'Hello from Orbit!',
    );
    printf("queued: %s\n", $result['data']['id'] ?? '?');
} catch (OrbitError $e) {
    fwrite(STDERR, "send failed: {$e->errorCode} — {$e->getMessage()}\n");
}

// Escape hatch — out-of-scope surfaces call request() directly:
$conf = $client->request(
    'POST',
    '/voice/conferences',
    null,
    ['name' => 'support-room-42'],
);
printf("conf: %s\n", $conf['data']['id'] ?? '?');

# Not yet on Maven Central — build + depend on the workspace module:
#   mvn -f packages/sdk-java/pom.xml install
export ORBIT_API_KEY=dv_test_sk_your_key_here

import io.devotel.orbit.OrbitClient;
import io.devotel.orbit.errors.OrbitError;

import java.util.Map;

OrbitClient client = OrbitClient.fromEnv();
try {
    Map<String, Object> result = client.messages.sendSms(
        "+14155552671",
        "Hello from Orbit!"
    );
    System.out.println("queued: " + result.get("data"));
} catch (OrbitError e) {
    System.err.println("send failed: " + e.getCode() + " — " + e.getMessage());
}

// Escape hatch — out-of-scope surfaces call request() directly:
Map<String, Object> conf = client.request(
    "POST",
    "/voice/conferences",
    null,
    Map.of("name", "support-room-42"),
    null
);

# Not yet on NuGet — add the workspace project reference:
#   dotnet add reference packages/sdk-csharp
export ORBIT_API_KEY=dv_test_sk_your_key_here

// xmlns/pep: the .NET client ships as Orbit.Sdk in the monorepo.
using Orbit.Sdk;
using Orbit.Sdk.Errors;

try
{
    var client = OrbitClient.FromEnv();
    var result = await client.Messages.SendSmsAsync(
        "+14155552671",
        "Hello from Orbit!"
    );
    if (result.TryGetProperty("data", out var data) &&
        data.TryGetProperty("id", out var id))
        Console.WriteLine($"queued: {id.GetString()}");
}
catch (OrbitError e)
{
    Console.Error.WriteLine($"send failed: {e.Code} — {e.Message}");
}

// Escape hatch — out-of-scope surfaces call RequestAsync directly:
var conf = await client.RequestAsync(
    "POST",
    "/voice/conferences",
    jsonBody: new Dictionary<string, object?>
    {
        ["name"] = "support-room-42"
    }
);