Real APIs, generated

We took the OpenAPI documents that OpenAI, Anthropic, GitHub and others publish and ran each one through Octri. Every API comes out as ten client libraries, each in its own repository with build instructions, tests and a CI workflow. Open the one in your language and read the code.

10 APIs · 100 repositories · public specs

Sample SDKs and docs sites, by API

OpenAISDK
index.tsRepository
import { OpenAI } from "@octridev/openai";

async function main() {
  const client = new OpenAI({
    // Optional: replaces the default server and any server an operation declares.
    baseUrl: "https://api.openai.com/v1",
    auth: { apiKeyAuth: process.env.API_TOKEN! },
  });
  const result = await client.chat.getCompletion({ completionId: "completion-1" });
  console.log(result);
}

main().catch(console.error);
main.pyRepository
import os

from octridev_openai import ClientConfig, ClientAuthConfig, OpenAI

config = ClientConfig(
    # Optional: replaces the default server and any server an operation declares.
    base_url="https://api.openai.com/v1",
    auth=ClientAuthConfig(api_key_auth=os.environ["API_TOKEN"]),
)
client = OpenAI(config)
result = client.chat.get_completion(completion_id="completion-1")
print(result)
main.goRepository
package main

import (
	"context"
	"fmt"
	"os"

	sdk "github.com/OctriDev/openai-go-showcase-sdk"
)

func main() {
	ctx := context.Background()
	config := sdk.ClientConfig{
		// Optional: replaces the default server and any server an operation declares.
		BaseURL: "https://api.openai.com/v1",
		Auth: &sdk.ClientAuthConfig{ApiKeyAuth: os.Getenv("API_TOKEN")},
	}
	client := sdk.NewOpenAI(config)
	result, err := client.Chat.GetCompletion(ctx, sdk.GetChatCompletionParams{CompletionId: "completion-1"})
	if err != nil {
		panic(err)
	}
	fmt.Printf("%d choices\n", len(result.Choices))
}
Main.javaRepository
import dev.octri.showcase.openai.*;
import dev.octri.showcase.openai.methods.Chat;

public final class Example {
    public static void main(String[] args) throws Exception {
        var config = new SdkConfig.ClientConfig();
        // Optional: replaces the default server and any server an operation declares.
        config.baseUrl = "https://api.openai.com/v1";
        var auth = new SdkConfig.ClientAuthConfig();
        auth.apiKeyAuth = System.getenv("API_TOKEN");
        config.auth = auth;
        var client = new OpenAI(config);
        var result = client.chat.getCompletion(Chat.GetChatCompletionRequest.builder().completionId("completion-1").build());
        System.out.println(result);
    }
}
main.dartRepository
import 'dart:io';

import 'package:octridev_openai/octridev_openai.dart';

Future<void> main() async {
  final config = ClientConfig(
    // Optional: replaces the default server and any server an operation declares.
    baseUrl: "https://api.openai.com/v1",
    auth: ClientAuthConfig(apiKeyAuth: Platform.environment['API_TOKEN']!),
  );
  final client = OpenAI(config);
  final result = await client.chat.getCompletion(completionId: 'completion-1');
  print(result);
}
main.rbRepository
require "octridev_openai"

config = OctridevOpenai::ClientConfig.new
# Optional: replaces the default server and any server an operation declares.
config.base_url = "https://api.openai.com/v1"
auth = OctridevOpenai::ClientAuthConfig.new
auth.api_key_auth = ENV.fetch("API_TOKEN")
config.auth = auth
client = OctridevOpenai::OpenAI.new(config)
result = client.chat.get_completion(completion_id: "completion-1")
p result
index.phpRepository
<?php

require __DIR__ . '/vendor/autoload.php';

use octridev_openai\ClientConfig;
use octridev_openai\SdkConfig;
use octridev_openai\ClientAuthConfig;
use octridev_openai\OpenAI;

$config = new ClientConfig();
// Optional: replaces the default server and any server an operation declares.
$config->baseUrl = "https://api.openai.com/v1";
$auth = new ClientAuthConfig();
$auth->apiKeyAuth = getenv('API_TOKEN') ?: throw new RuntimeException('API_TOKEN is required');
$config->auth = $auth;
$client = new OpenAI($config);
$result = $client->chat->getCompletion(completionId: "completion-1");
var_dump($result);
main.rsRepository
use octridev_openai::{ClientConfig, ClientAuthConfig, OpenAI};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let config = ClientConfig {
        // Optional: replaces the default server and any server an operation declares.
        base_url: Some("https://api.openai.com/v1".to_string()),
        auth: Some(ClientAuthConfig { api_key_auth: Some(std::env::var("API_TOKEN")?), ..Default::default() }),
        ..Default::default()
    };
    let client = OpenAI::new(config);
    let result = client.chat.get_completion("completion-1".to_string(), None)?;
    println!("{result:#?}");
    Ok(())
}
main.swiftRepository
import Foundation
import Octridevopenai

@main
struct Example {
    static func main() async throws {
        let config = ClientConfig(
            // Optional: replaces the default server and any server an operation declares.
            baseUrl: "https://api.openai.com/v1",
            auth: ClientAuthConfig(apiKeyAuth: ProcessInfo.processInfo.environment["API_TOKEN"]!)
        )
        let client = OpenAI(config: config)
        let result = try await client.chat.getCompletion(completionId: "completion-1")
        print(result)
    }
}
Main.ktRepository
import dev.octri.showcase.openai.*

fun main() {
    val config = ClientConfig(
        // Optional: replaces the default server and any server an operation declares.
        baseUrl = "https://api.openai.com/v1",
        auth = ClientAuthConfig(apiKeyAuth = System.getenv("API_TOKEN")),
    )
    val client = OpenAI(config)
    val result = client.chat.getCompletion(completionId = "completion-1")
    println(result)
}

OpenAI

Chat, responses, embeddings, files, fine-tuning and the rest of the OpenAI platform API.

Operations
360
Languages
10
Spec score
7.6/10
OpenAIDocs

OpenAI docs

A dark site in OpenAI green, set in Inter, with seven tabs across the top bar and the current page filled green in the sidebar.

Layout
Full width
Typeface
Inter
Scheme
Dark
Settings
+34 more
Visit the docs
AnthropicSDK
index.tsRepository
import { Anthropic } from "@octridev/anthropic";

async function main() {
  const client = new Anthropic({
    // Optional: replaces the default server and any server an operation declares.
    baseUrl: "https://api.anthropic.com",
    auth: { apiKeyAuth: process.env.API_TOKEN! },
  });
  const result = await client.beta.agents.retrieve({ agentId: "agent_011CZkYpogX7uDKUyvBTophP" });
  console.log(result);
}

main().catch(console.error);
main.pyRepository
import os

from octridev_anthropic import ClientConfig, ClientAuthConfig, Anthropic

config = ClientConfig(
    # Optional: replaces the default server and any server an operation declares.
    base_url="https://api.anthropic.com",
    auth=ClientAuthConfig(api_key_auth=os.environ["API_TOKEN"]),
)
client = Anthropic(config)
result = client.beta.agents.retrieve(agent_id="agent_011CZkYpogX7uDKUyvBTophP")
print(result)
main.goRepository
package main

import (
	"context"
	"fmt"
	"os"

	sdk "github.com/OctriDev/anthropic-go-showcase-sdk"
)

func main() {
	ctx := context.Background()
	config := sdk.ClientConfig{
		// Optional: replaces the default server and any server an operation declares.
		BaseURL: "https://api.anthropic.com",
		Auth: &sdk.ClientAuthConfig{ApiKeyAuth: os.Getenv("API_TOKEN")},
	}
	client := sdk.NewAnthropic(config)
	result, err := client.Beta.Agents.Retrieve(ctx, sdk.RetrieveBetaAgentsParams{AgentId: "agent_011CZkYpogX7uDKUyvBTophP"})
	if err != nil {
		panic(err)
	}
	fmt.Printf("%d tools\n", len(result.Tools))
}
Main.javaRepository
import dev.octri.showcase.anthropic.*;
import dev.octri.showcase.anthropic.methods.beta.BetaAgents;

public final class Example {
    public static void main(String[] args) throws Exception {
        var config = new SdkConfig.ClientConfig();
        // Optional: replaces the default server and any server an operation declares.
        config.baseUrl = "https://api.anthropic.com";
        var auth = new SdkConfig.ClientAuthConfig();
        auth.apiKeyAuth = System.getenv("API_TOKEN");
        config.auth = auth;
        var client = new Anthropic(config);
        var result = client.beta.agents.retrieve(BetaAgents.RetrieveBetaAgentsRequest.builder().agentId("agent_011CZkYpogX7uDKUyvBTophP").build());
        System.out.println(result);
    }
}
main.dartRepository
import 'dart:io';

import 'package:octridev_anthropic/octridev_anthropic.dart';

Future<void> main() async {
  final config = ClientConfig(
    // Optional: replaces the default server and any server an operation declares.
    baseUrl: "https://api.anthropic.com",
    auth: ClientAuthConfig(apiKeyAuth: Platform.environment['API_TOKEN']!),
  );
  final client = Anthropic(config);
  final result = await client.beta.agents.retrieve(agentId: 'agent_011CZkYpogX7uDKUyvBTophP');
  print(result);
}
main.rbRepository
require "octridev_anthropic"

config = OctridevAnthropic::ClientConfig.new
# Optional: replaces the default server and any server an operation declares.
config.base_url = "https://api.anthropic.com"
auth = OctridevAnthropic::ClientAuthConfig.new
auth.api_key_auth = ENV.fetch("API_TOKEN")
config.auth = auth
client = OctridevAnthropic::Anthropic.new(config)
result = client.beta.agents.retrieve(agent_id: "agent_011CZkYpogX7uDKUyvBTophP")
p result
index.phpRepository
<?php

require __DIR__ . '/vendor/autoload.php';

use octridev_anthropic\ClientConfig;
use octridev_anthropic\SdkConfig;
use octridev_anthropic\ClientAuthConfig;
use octridev_anthropic\Anthropic;

$config = new ClientConfig();
// Optional: replaces the default server and any server an operation declares.
$config->baseUrl = "https://api.anthropic.com";
$auth = new ClientAuthConfig();
$auth->apiKeyAuth = getenv('API_TOKEN') ?: throw new RuntimeException('API_TOKEN is required');
$config->auth = $auth;
$client = new Anthropic($config);
$result = $client->beta->agents->retrieve(agentId: "agent_011CZkYpogX7uDKUyvBTophP");
var_dump($result);
main.rsRepository
use octridev_anthropic::{ClientConfig, ClientAuthConfig, Anthropic};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let config = ClientConfig {
        // Optional: replaces the default server and any server an operation declares.
        base_url: Some("https://api.anthropic.com".to_string()),
        auth: Some(ClientAuthConfig { api_key_auth: Some(std::env::var("API_TOKEN")?), ..Default::default() }),
        ..Default::default()
    };
    let client = Anthropic::new(config);
    let result = client.beta.agents.retrieve(octridev_anthropic::methods::beta_agents::RetrieveBetaAgentsParams { agent_id: "agent_011CZkYpogX7uDKUyvBTophP".to_string(), version: None, anthropic_version: None, anthropic_beta: None, anthropic_workspace_id: None }, None)?;
    println!("{result:#?}");
    Ok(())
}
main.swiftRepository
import Foundation
import Octridevanthropic

@main
struct Example {
    static func main() async throws {
        let config = ClientConfig(
            // Optional: replaces the default server and any server an operation declares.
            baseUrl: "https://api.anthropic.com",
            auth: ClientAuthConfig(apiKeyAuth: ProcessInfo.processInfo.environment["API_TOKEN"]!)
        )
        let client = Anthropic(config: config)
        let result = try await client.beta.agents.retrieve(agentId: "agent_011CZkYpogX7uDKUyvBTophP")
        print(result)
    }
}
Main.ktRepository
import dev.octri.showcase.anthropic.*

fun main() {
    val config = ClientConfig(
        // Optional: replaces the default server and any server an operation declares.
        baseUrl = "https://api.anthropic.com",
        auth = ClientAuthConfig(apiKeyAuth = System.getenv("API_TOKEN")),
    )
    val client = Anthropic(config)
    val result = client.beta.agents.retrieve(agentId = "agent_011CZkYpogX7uDKUyvBTophP")
    println(result)
}

Anthropic

Messages, models, message batches, files and the rest of the Anthropic API.

Operations
244
Languages
10
AnthropicDocs

Anthropic docs

Anthropic clay on white, Source Serif 4 headings over Source Sans 3, in a framed column, with the current page tinted clay in the sidebar.

Layout
Framed
Typeface
Source Sans 3
Scheme
Light
Settings
+34 more
Visit the docs
GitHubSDK
index.tsRepository
import { GitHubV3REST } from "@octridev/github";

async function main() {
  const client = new GitHubV3REST({
    // Optional: replaces the default server and any server an operation declares.
    baseUrl: "https://api.github.com",
    auth: { bearer: process.env.API_TOKEN! },
  });
  const result = await client.search.labels({ repositoryId: 1, q: "q" });
  console.log(result);
}

main().catch(console.error);
main.pyRepository
import os

from octridev_github import ClientConfig, ClientAuthConfig, GitHubV3REST

config = ClientConfig(
    # Optional: replaces the default server and any server an operation declares.
    base_url="https://api.github.com",
    auth=ClientAuthConfig(bearer=os.environ["API_TOKEN"]),
)
client = GitHubV3REST(config)
result = client.search.labels(repository_id=1, q="q")
print(result)
main.goRepository
package main

import (
	"context"
	"fmt"
	"os"

	sdk "github.com/OctriDev/github-go-showcase-sdk"
)

func main() {
	ctx := context.Background()
	config := sdk.ClientConfig{
		// Optional: replaces the default server and any server an operation declares.
		BaseURL: "https://api.github.com",
		Auth: &sdk.ClientAuthConfig{Bearer: os.Getenv("API_TOKEN")},
	}
	client := sdk.NewGitHubV3REST(config)
	result, err := client.Search.Labels(ctx, sdk.SearchLabelsParams{RepositoryId: 1, Q: "q"})
	if err != nil {
		panic(err)
	}
	fmt.Printf("%d items\n", len(result.Items))
}
Main.javaRepository
import dev.octri.showcase.github.*;
import dev.octri.showcase.github.methods.Search;

public final class Example {
    public static void main(String[] args) throws Exception {
        var config = new SdkConfig.ClientConfig();
        // Optional: replaces the default server and any server an operation declares.
        config.baseUrl = "https://api.github.com";
        var auth = new SdkConfig.ClientAuthConfig();
        auth.bearer = System.getenv("API_TOKEN");
        config.auth = auth;
        var client = new GitHubV3REST(config);
        var result = client.search.labels(Search.SearchLabelsRequest.builder().repositoryId(1L).q("q").build());
        System.out.println(result);
    }
}
main.dartRepository
import 'dart:io';

import 'package:octridev_github/octridev_github.dart';

Future<void> main() async {
  final config = ClientConfig(
    // Optional: replaces the default server and any server an operation declares.
    baseUrl: "https://api.github.com",
    auth: ClientAuthConfig(bearer: Platform.environment['API_TOKEN']!),
  );
  final client = GitHubV3REST(config);
  final result = await client.search.labels(repositoryId: 1, q: 'q');
  print(result);
}
main.rbRepository
require "octridev_github"

config = OctridevGithub::ClientConfig.new
# Optional: replaces the default server and any server an operation declares.
config.base_url = "https://api.github.com"
auth = OctridevGithub::ClientAuthConfig.new
auth.bearer = ENV.fetch("API_TOKEN")
config.auth = auth
client = OctridevGithub::GitHubV3REST.new(config)
result = client.search.labels(repository_id: 1, q_value: "q")
p result
index.phpRepository
<?php

require __DIR__ . '/vendor/autoload.php';

use octridev_github\ClientConfig;
use octridev_github\SdkConfig;
use octridev_github\ClientAuthConfig;
use octridev_github\GitHubV3REST;

$config = new ClientConfig();
// Optional: replaces the default server and any server an operation declares.
$config->baseUrl = "https://api.github.com";
$auth = new ClientAuthConfig();
$auth->bearer = getenv('API_TOKEN') ?: throw new RuntimeException('API_TOKEN is required');
$config->auth = $auth;
$client = new GitHubV3REST($config);
$result = $client->search->labels(repositoryId: 1, q: "q");
var_dump($result);
main.rsRepository
use octridev_github::{ClientConfig, ClientAuthConfig, GitHubV3REST};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let config = ClientConfig {
        // Optional: replaces the default server and any server an operation declares.
        base_url: Some("https://api.github.com".to_string()),
        auth: Some(ClientAuthConfig { bearer: Some(std::env::var("API_TOKEN")?), ..Default::default() }),
        ..Default::default()
    };
    let client = GitHubV3REST::new(config);
    let result = client.search.labels(octridev_github::methods::search::SearchLabelsParams { repository_id: 1, q: "q".to_string(), sort: None, order: None, per_page: None, page: None }, None)?;
    println!("{result:#?}");
    Ok(())
}
main.swiftRepository
import Foundation
import Octridevgithub

@main
struct Example {
    static func main() async throws {
        let config = ClientConfig(
            // Optional: replaces the default server and any server an operation declares.
            baseUrl: "https://api.github.com",
            auth: ClientAuthConfig(bearer: ProcessInfo.processInfo.environment["API_TOKEN"]!)
        )
        let client = GitHubV3REST(config: config)
        let result = try await client.search.labels(repositoryId: 1, q: "q")
        print(result)
    }
}
Main.ktRepository
import dev.octri.showcase.github.*
import dev.octri.showcase.github.methods.Search

fun main() {
    val config = ClientConfig(
        // Optional: replaces the default server and any server an operation declares.
        baseUrl = "https://api.github.com",
        auth = ClientAuthConfig(bearer = System.getenv("API_TOKEN")),
    )
    val client = GitHubV3REST(config)
    val result = client.search.labels(Search.SearchLabelsRequest(repositoryId = 1, q = "q"))
    println(result)
}

GitHub

Repositories, issues, pull requests, Actions and the rest of the GitHub REST API.

Operations
1,242
Languages
10
Spec score
6.9/10
GitHubDocs

GitHub docs

GitHub’s dark chrome with a near-black top bar, Mona Sans for text, IBM Plex Mono for code and the whole site held in one centred column.

Layout
Contained
Typeface
Mona Sans
Scheme
Dark
Settings
+34 more
Visit the docs
TwilioSDK
index.tsRepository
import { Twilio } from "@octridev/twilio";

async function main() {
  const client = new Twilio({
    // Optional: replaces the default server and any server an operation declares.
    baseUrl: "https://api.twilio.com",
    auth: {
      accountSidAuthToken: {
        username: process.env.API_USERNAME!,
        password: process.env.API_PASSWORD!,
      },
    },
  });
  const result = await client.addresses.dependentPhoneNumbers.list({
    accountSid: "ACaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
    addressSid: "ADaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
  });
  console.log(result);
}

main().catch(console.error);
main.pyRepository
import os

from octridev_twilio import ClientConfig, ClientAuthConfig, Twilio
from octridev_twilio.client import BasicCredentials

config = ClientConfig(
    # Optional: replaces the default server and any server an operation declares.
    base_url="https://api.twilio.com",
    auth=ClientAuthConfig(
        account_sid_auth_token=BasicCredentials(
            username=os.environ["API_USERNAME"], password=os.environ["API_PASSWORD"]
        )
    ),
)
client = Twilio(config)
result = client.addresses.dependent_phone_numbers.list(
    account_sid="ACaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
    address_sid="ADaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
)
print(result)
main.goRepository
package main

import (
	"context"
	"fmt"
	"os"

	sdk "github.com/OctriDev/twilio-go-showcase-sdk"
)

func main() {
	ctx := context.Background()
	config := sdk.ClientConfig{
		// Optional: replaces the default server and any server an operation declares.
		BaseURL: "https://api.twilio.com",
		Auth: &sdk.ClientAuthConfig{AccountSidAuthToken: &sdk.BasicCredentials{Username: os.Getenv("API_USERNAME"), Password: os.Getenv("API_PASSWORD")}},
	}
	client := sdk.NewTwilio(config)
	result, err := client.Addresses.DependentPhoneNumbers.List(ctx, sdk.ListAddressesDependentPhoneNumbersParams{AccountSid: "ACaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", AddressSid: "ADaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"})
	if err != nil {
		panic(err)
	}
	fmt.Printf("%d dependent_phone_numbers\n", len(result.DependentPhoneNumbers))
}
Main.javaRepository
import dev.octri.showcase.twilio.*;
import dev.octri.showcase.twilio.methods.addresses.AddressesDependentPhoneNumbers;

public final class Example {
    public static void main(String[] args) throws Exception {
        var config = new SdkConfig.ClientConfig();
        // Optional: replaces the default server and any server an operation declares.
        config.baseUrl = "https://api.twilio.com";
        var auth = new SdkConfig.ClientAuthConfig();
        auth.accountSidAuthToken = new SdkConfig.BasicCredentials(System.getenv("API_USERNAME"), System.getenv("API_PASSWORD"));
        config.auth = auth;
        var client = new Twilio(config);
        var result = client.addresses.dependentPhoneNumbers.list(AddressesDependentPhoneNumbers.ListAddressesDependentPhoneNumbersRequest.builder().accountSid("ACaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa").addressSid("ADaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa").build());
        System.out.println(result);
    }
}
main.dartRepository
import 'dart:io';

import 'package:octridev_twilio/octridev_twilio.dart';

Future<void> main() async {
  final config = ClientConfig(
    // Optional: replaces the default server and any server an operation declares.
    baseUrl: "https://api.twilio.com",
    auth: ClientAuthConfig(accountSidAuthToken: BasicCredentials(username: Platform.environment['API_USERNAME']!, password: Platform.environment['API_PASSWORD']!)),
  );
  final client = Twilio(config);
  final result = await client.addresses.dependentPhoneNumbers.list(accountSid: 'ACaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa', addressSid: 'ADaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa');
  print(result);
}
main.rbRepository
require "octridev_twilio"

config = OctridevTwilio::ClientConfig.new
# Optional: replaces the default server and any server an operation declares.
config.base_url = "https://api.twilio.com"
auth = OctridevTwilio::ClientAuthConfig.new
auth.account_sid_auth_token = OctridevTwilio::BasicCredentials.new(username: ENV.fetch("API_USERNAME"), password: ENV.fetch("API_PASSWORD"))
config.auth = auth
client = OctridevTwilio::Twilio.new(config)
result = client.addresses.dependent_phone_numbers.list(account_sid: "ACaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", address_sid: "ADaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")
p result
index.phpRepository
<?php

require __DIR__ . '/vendor/autoload.php';

use octridev_twilio\ClientConfig;
use octridev_twilio\SdkConfig;
use octridev_twilio\ClientAuthConfig;
use octridev_twilio\BasicCredentials;
use octridev_twilio\Twilio;

$config = new ClientConfig();
// Optional: replaces the default server and any server an operation declares.
$config->baseUrl = "https://api.twilio.com";
$auth = new ClientAuthConfig();
$auth->accountSidAuthToken = new BasicCredentials(getenv('API_USERNAME') ?: throw new RuntimeException('API_USERNAME is required'), getenv('API_PASSWORD') ?: throw new RuntimeException('API_PASSWORD is required'));
$config->auth = $auth;
$client = new Twilio($config);
$result = $client->addresses->dependentPhoneNumbers->list_(accountSid: "ACaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", addressSid: "ADaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
var_dump($result);
main.rsRepository
use octridev_twilio::{ClientConfig, ClientAuthConfig, Twilio};
use octridev_twilio::client::BasicCredentials;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let config = ClientConfig {
        // Optional: replaces the default server and any server an operation declares.
        base_url: Some("https://api.twilio.com".to_string()),
        auth: Some(ClientAuthConfig { account_sid_auth_token: Some(BasicCredentials { username: std::env::var("API_USERNAME")?, password: std::env::var("API_PASSWORD")? }), ..Default::default() }),
        ..Default::default()
    };
    let client = Twilio::new(config);
    let result = client.addresses.dependent_phone_numbers.list(octridev_twilio::methods::addresses_dependent_phone_numbers::ListAddressesDependentPhoneNumbersParams { account_sid: "ACaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa".to_string(), address_sid: "ADaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa".to_string(), page_size: None, page: None, page_token: None }, None)?;
    println!("{result:#?}");
    Ok(())
}
main.swiftRepository
import Foundation
import Octridevtwilio

@main
struct Example {
    static func main() async throws {
        let config = ClientConfig(
            // Optional: replaces the default server and any server an operation declares.
            baseUrl: "https://api.twilio.com",
            auth: ClientAuthConfig(accountSidAuthToken: BasicCredentials(username: ProcessInfo.processInfo.environment["API_USERNAME"]!, password: ProcessInfo.processInfo.environment["API_PASSWORD"]!))
        )
        let client = Twilio(config: config)
        let result = try await client.addresses.dependentPhoneNumbers.list(accountSid: "ACaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", addressSid: "ADaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")
        print(result)
    }
}
Main.ktRepository
import dev.octri.showcase.twilio.*

fun main() {
    val config = ClientConfig(
        // Optional: replaces the default server and any server an operation declares.
        baseUrl = "https://api.twilio.com",
        auth = ClientAuthConfig(accountSidAuthToken = BasicCredentials(username = System.getenv("API_USERNAME"), password = System.getenv("API_PASSWORD"))),
    )
    val client = Twilio(config)
    val result = client.addresses.dependentPhoneNumbers.list(accountSid = "ACaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", addressSid = "ADaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")
    println(result)
}

Twilio

Messaging, voice, phone numbers and the rest of the Twilio REST API.

Operations
197
Languages
10
Spec score
7.3/10
TwilioDocs

Twilio docs

Twilio red on white in Work Sans, with square corners and the tabs stacked under the logo. The home page drops the sidebar for a full-width banner.

Layout
Floating
Typeface
Work Sans
Scheme
Light
Settings
+34 more
Visit the docs
ResendSDK
index.tsRepository
import { Resend } from "@octridev/resend";

async function main() {
  const client = new Resend({
    // Optional: replaces the default server and any server an operation declares.
    baseUrl: "https://api.resend.com",
    auth: { bearerAuth: process.env.API_TOKEN! },
  });
  const result = await client.domains.get({ domainId: "domain-1" });
  console.log(result);
}

main().catch(console.error);
main.pyRepository
import os

from octridev_resend import ClientConfig, ClientAuthConfig, Resend

config = ClientConfig(
    # Optional: replaces the default server and any server an operation declares.
    base_url="https://api.resend.com",
    auth=ClientAuthConfig(bearer_auth=os.environ["API_TOKEN"]),
)
client = Resend(config)
result = client.domains.get(domain_id="domain-1")
print(result)
main.goRepository
package main

import (
	"context"
	"fmt"
	"os"

	sdk "github.com/OctriDev/resend-go-showcase-sdk"
)

func main() {
	ctx := context.Background()
	config := sdk.ClientConfig{
		// Optional: replaces the default server and any server an operation declares.
		BaseURL: "https://api.resend.com",
		Auth: &sdk.ClientAuthConfig{BearerAuth: os.Getenv("API_TOKEN")},
	}
	client := sdk.NewResend(config)
	result, err := client.Domains.Get(ctx, sdk.DomainsGetParams{DomainId: "domain-1"})
	if err != nil {
		panic(err)
	}
	fmt.Printf("%d records\n", len(result.Records))
}
Main.javaRepository
import dev.octri.showcase.resend.*;
import dev.octri.showcase.resend.methods.Domains;

public final class Example {
    public static void main(String[] args) throws Exception {
        var config = new SdkConfig.ClientConfig();
        // Optional: replaces the default server and any server an operation declares.
        config.baseUrl = "https://api.resend.com";
        var auth = new SdkConfig.ClientAuthConfig();
        auth.bearerAuth = System.getenv("API_TOKEN");
        config.auth = auth;
        var client = new Resend(config);
        var result = client.domains.get(Domains.DomainsGetRequest.builder().domainId("domain-1").build());
        System.out.println(result);
    }
}
main.dartRepository
import 'dart:io';

import 'package:octridev_resend/octridev_resend.dart';

Future<void> main() async {
  final config = ClientConfig(
    // Optional: replaces the default server and any server an operation declares.
    baseUrl: "https://api.resend.com",
    auth: ClientAuthConfig(bearerAuth: Platform.environment['API_TOKEN']!),
  );
  final client = Resend(config);
  final result = await client.domains.get_(domainId: 'domain-1');
  print(result);
}
main.rbRepository
require "octridev_resend"

config = OctridevResend::ClientConfig.new
# Optional: replaces the default server and any server an operation declares.
config.base_url = "https://api.resend.com"
auth = OctridevResend::ClientAuthConfig.new
auth.bearer_auth = ENV.fetch("API_TOKEN")
config.auth = auth
client = OctridevResend::Resend.new(config)
result = client.domains.get(domain_id: "domain-1")
p result
index.phpRepository
<?php

require __DIR__ . '/vendor/autoload.php';

use octridev_resend\ClientConfig;
use octridev_resend\SdkConfig;
use octridev_resend\ClientAuthConfig;
use octridev_resend\Resend;

$config = new ClientConfig();
// Optional: replaces the default server and any server an operation declares.
$config->baseUrl = "https://api.resend.com";
$auth = new ClientAuthConfig();
$auth->bearerAuth = getenv('API_TOKEN') ?: throw new RuntimeException('API_TOKEN is required');
$config->auth = $auth;
$client = new Resend($config);
$result = $client->domains->get(domainId: "domain-1");
var_dump($result);
main.rsRepository
use octridev_resend::{ClientConfig, ClientAuthConfig, Resend};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let config = ClientConfig {
        // Optional: replaces the default server and any server an operation declares.
        base_url: Some("https://api.resend.com".to_string()),
        auth: Some(ClientAuthConfig { bearer_auth: Some(std::env::var("API_TOKEN")?), ..Default::default() }),
        ..Default::default()
    };
    let client = Resend::new(config);
    let result = client.domains.get("domain-1".to_string(), None)?;
    println!("{result:#?}");
    Ok(())
}
main.swiftRepository
import Foundation
import Octridevresend

@main
struct Example {
    static func main() async throws {
        let config = ClientConfig(
            // Optional: replaces the default server and any server an operation declares.
            baseUrl: "https://api.resend.com",
            auth: ClientAuthConfig(bearerAuth: ProcessInfo.processInfo.environment["API_TOKEN"]!)
        )
        let client = Resend(config: config)
        let result = try await client.domains.get(domainId: "domain-1")
        print(result)
    }
}
Main.ktRepository
import dev.octri.showcase.resend.*

fun main() {
    val config = ClientConfig(
        // Optional: replaces the default server and any server an operation declares.
        baseUrl = "https://api.resend.com",
        auth = ClientAuthConfig(bearerAuth = System.getenv("API_TOKEN")),
    )
    val client = Resend(config)
    val result = client.domains.get(domainId = "domain-1")
    println(result)
}

Resend

Emails, domains, audiences, contacts and the rest of the Resend API.

Operations
139
Languages
10
ResendDocs

Resend docs

Black and white like Resend, set in Inter with Fira Code for code, the tabs centred in a transparent top bar.

Layout
Contained
Typeface
Inter
Scheme
Dark
Settings
+34 more
Visit the docs
ClerkSDK
index.tsRepository
import { ClerkBackend } from "@octridev/clerk";

async function main() {
  const client = new ClerkBackend({
    // Optional: replaces the default server and any server an operation declares.
    baseUrl: "https://api.clerk.com/v1",
    auth: { bearerAuth: process.env.API_TOKEN! },
  });
  const result = await client.m2MTokens.get({ subject: "mch_aaaaaaaaaaaaaaaaaaaaaaaaaaa" });
  console.log(result);
}

main().catch(console.error);
main.pyRepository
import os

from octridev_clerk import ClientConfig, ClientAuthConfig, ClerkBackend

config = ClientConfig(
    # Optional: replaces the default server and any server an operation declares.
    base_url="https://api.clerk.com/v1",
    auth=ClientAuthConfig(bearer_auth=os.environ["API_TOKEN"]),
)
client = ClerkBackend(config)
result = client.m2_mtokens.get(subject="mch_aaaaaaaaaaaaaaaaaaaaaaaaaaa")
print(result)
main.goRepository
package main

import (
	"context"
	"fmt"
	"os"

	sdk "github.com/OctriDev/clerk-go-showcase-sdk"
)

func main() {
	ctx := context.Background()
	config := sdk.ClientConfig{
		// Optional: replaces the default server and any server an operation declares.
		BaseURL: "https://api.clerk.com/v1",
		Auth: &sdk.ClientAuthConfig{BearerAuth: os.Getenv("API_TOKEN")},
	}
	client := sdk.NewClerkBackend(config)
	result, err := client.M2MTokens.Get(ctx, sdk.GetM2MTokensParams{Subject: "mch_aaaaaaaaaaaaaaaaaaaaaaaaaaa"})
	if err != nil {
		panic(err)
	}
	fmt.Printf("%d m2m_tokens\n", len(result.M2mTokens))
}
Main.javaRepository
import dev.octri.showcase.clerk.*;
import dev.octri.showcase.clerk.methods.M2MTokens;

public final class Example {
    public static void main(String[] args) throws Exception {
        var config = new SdkConfig.ClientConfig();
        // Optional: replaces the default server and any server an operation declares.
        config.baseUrl = "https://api.clerk.com/v1";
        var auth = new SdkConfig.ClientAuthConfig();
        auth.bearerAuth = System.getenv("API_TOKEN");
        config.auth = auth;
        var client = new ClerkBackend(config);
        var result = client.m2MTokens.get(M2MTokens.GetM2MTokensRequest.builder().subject("mch_aaaaaaaaaaaaaaaaaaaaaaaaaaa").build());
        System.out.println(result);
    }
}
main.dartRepository
import 'dart:io';

import 'package:octridev_clerk/octridev_clerk.dart';

Future<void> main() async {
  final config = ClientConfig(
    // Optional: replaces the default server and any server an operation declares.
    baseUrl: "https://api.clerk.com/v1",
    auth: ClientAuthConfig(bearerAuth: Platform.environment['API_TOKEN']!),
  );
  final client = ClerkBackend(config);
  final result = await client.m2MTokens.get_(subject: 'mch_aaaaaaaaaaaaaaaaaaaaaaaaaaa');
  print(result);
}
main.rbRepository
require "octridev_clerk"

config = OctridevClerk::ClientConfig.new
# Optional: replaces the default server and any server an operation declares.
config.base_url = "https://api.clerk.com/v1"
auth = OctridevClerk::ClientAuthConfig.new
auth.bearer_auth = ENV.fetch("API_TOKEN")
config.auth = auth
client = OctridevClerk::ClerkBackend.new(config)
result = client.m2_mtokens.get(subject: "mch_aaaaaaaaaaaaaaaaaaaaaaaaaaa")
p result
index.phpRepository
<?php

require __DIR__ . '/vendor/autoload.php';

use octridev_clerk\ClientConfig;
use octridev_clerk\SdkConfig;
use octridev_clerk\ClientAuthConfig;
use octridev_clerk\ClerkBackend;

$config = new ClientConfig();
// Optional: replaces the default server and any server an operation declares.
$config->baseUrl = "https://api.clerk.com/v1";
$auth = new ClientAuthConfig();
$auth->bearerAuth = getenv('API_TOKEN') ?: throw new RuntimeException('API_TOKEN is required');
$config->auth = $auth;
$client = new ClerkBackend($config);
$result = $client->m2MTokens->get(subject: "mch_aaaaaaaaaaaaaaaaaaaaaaaaaaa");
var_dump($result);
main.rsRepository
use octridev_clerk::{ClientConfig, ClientAuthConfig, ClerkBackend};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let config = ClientConfig {
        // Optional: replaces the default server and any server an operation declares.
        base_url: Some("https://api.clerk.com/v1".to_string()),
        auth: Some(ClientAuthConfig { bearer_auth: Some(std::env::var("API_TOKEN")?), ..Default::default() }),
        ..Default::default()
    };
    let client = ClerkBackend::new(config);
    let result = client.m2_mtokens.get(octridev_clerk::methods::m2_mtokens::GetM2MtokensParams { subject: "mch_aaaaaaaaaaaaaaaaaaaaaaaaaaa".to_string(), revoked: None, expired: None, limit: None, offset: None }, None)?;
    println!("{result:#?}");
    Ok(())
}
main.swiftRepository
import Foundation
import Octridevclerk

@main
struct Example {
    static func main() async throws {
        let config = ClientConfig(
            // Optional: replaces the default server and any server an operation declares.
            baseUrl: "https://api.clerk.com/v1",
            auth: ClientAuthConfig(bearerAuth: ProcessInfo.processInfo.environment["API_TOKEN"]!)
        )
        let client = ClerkBackend(config: config)
        let result = try await client.m2MTokens.get(subject: "mch_aaaaaaaaaaaaaaaaaaaaaaaaaaa")
        print(result)
    }
}
Main.ktRepository
import dev.octri.showcase.clerk.*

fun main() {
    val config = ClientConfig(
        // Optional: replaces the default server and any server an operation declares.
        baseUrl = "https://api.clerk.com/v1",
        auth = ClientAuthConfig(bearerAuth = System.getenv("API_TOKEN")),
    )
    val client = ClerkBackend(config)
    val result = client.m2MTokens.get(subject = "mch_aaaaaaaaaaaaaaaaaaaaaaaaaaa")
    println(result)
}

Clerk

Users, organizations, sessions, invitations and the rest of the Clerk Backend API.

Operations
256
Languages
10
ClerkDocs

Clerk docs

Clerk violet on white in Plus Jakarta Sans, under a frosted top bar, with rounded corners and Nord for code.

Layout
Contained
Typeface
Plus Jakarta Sans
Scheme
Light
Settings
+34 more
Visit the docs
VercelSDK
index.tsRepository
import { Vercel } from "@octridev/vercel";

async function main() {
  const client = new Vercel({
    // Optional: replaces the default server and any server an operation declares.
    baseUrl: "https://api.vercel.com",
    auth: { bearerToken: process.env.API_TOKEN! },
  });
  const result = await client.logDrains.getConfigurable({ id: "id-1" });
  console.log(result);
}

main().catch(console.error);
main.pyRepository
import os

from octridev_vercel import ClientConfig, ClientAuthConfig, Vercel

config = ClientConfig(
    # Optional: replaces the default server and any server an operation declares.
    base_url="https://api.vercel.com",
    auth=ClientAuthConfig(bearer_token=os.environ["API_TOKEN"]),
)
client = Vercel(config)
result = client.log_drains.get_configurable(id="id-1")
print(result)
main.goRepository
package main

import (
	"context"
	"fmt"
	"os"

	sdk "github.com/OctriDev/vercel-go-showcase-sdk"
)

func main() {
	ctx := context.Background()
	config := sdk.ClientConfig{
		// Optional: replaces the default server and any server an operation declares.
		BaseURL: "https://api.vercel.com",
		Auth: &sdk.ClientAuthConfig{BearerToken: os.Getenv("API_TOKEN")},
	}
	client := sdk.NewVercel(config)
	result, err := client.LogDrains.GetConfigurable(ctx, sdk.GetConfigurableLogDrainParams{Id: "id-1"})
	if err != nil {
		panic(err)
	}
	fmt.Printf("%d projectsMetadata\n", len(result.ProjectsMetadata))
}
Main.javaRepository
import dev.octri.showcase.vercel.*;
import dev.octri.showcase.vercel.methods.LogDrains;

public final class Example {
    public static void main(String[] args) throws Exception {
        var config = new SdkConfig.ClientConfig();
        // Optional: replaces the default server and any server an operation declares.
        config.baseUrl = "https://api.vercel.com";
        var auth = new SdkConfig.ClientAuthConfig();
        auth.bearerToken = System.getenv("API_TOKEN");
        config.auth = auth;
        var client = new Vercel(config);
        var result = client.logDrains.getConfigurable(LogDrains.GetConfigurableLogDrainRequest.builder().id("id-1").build());
        System.out.println(result);
    }
}
main.dartRepository
import 'dart:io';

import 'package:octridev_vercel/octridev_vercel.dart';

Future<void> main() async {
  final config = ClientConfig(
    // Optional: replaces the default server and any server an operation declares.
    baseUrl: "https://api.vercel.com",
    auth: ClientAuthConfig(bearerToken: Platform.environment['API_TOKEN']!),
  );
  final client = Vercel(config);
  final result = await client.logDrains.getConfigurable(id: 'id-1');
  print(result);
}
main.rbRepository
require "octridev_vercel"

config = OctridevVercel::ClientConfig.new
# Optional: replaces the default server and any server an operation declares.
config.base_url = "https://api.vercel.com"
auth = OctridevVercel::ClientAuthConfig.new
auth.bearer_token = ENV.fetch("API_TOKEN")
config.auth = auth
client = OctridevVercel::Vercel.new(config)
result = client.log_drains.get_configurable(id: "id-1")
p result
index.phpRepository
<?php

require __DIR__ . '/vendor/autoload.php';

use octridev_vercel\ClientConfig;
use octridev_vercel\SdkConfig;
use octridev_vercel\ClientAuthConfig;
use octridev_vercel\Vercel;

$config = new ClientConfig();
// Optional: replaces the default server and any server an operation declares.
$config->baseUrl = "https://api.vercel.com";
$auth = new ClientAuthConfig();
$auth->bearerToken = getenv('API_TOKEN') ?: throw new RuntimeException('API_TOKEN is required');
$config->auth = $auth;
$client = new Vercel($config);
$result = $client->logDrains->getConfigurable(id: "id-1");
var_dump($result);
main.rsRepository
use octridev_vercel::{ClientConfig, ClientAuthConfig, Vercel};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let config = ClientConfig {
        // Optional: replaces the default server and any server an operation declares.
        base_url: Some("https://api.vercel.com".to_string()),
        auth: Some(ClientAuthConfig { bearer_token: Some(std::env::var("API_TOKEN")?), ..Default::default() }),
        ..Default::default()
    };
    let client = Vercel::new(config);
    let result = client.log_drains.get_configurable("id-1".to_string(), None, None, None)?;
    println!("{result:#?}");
    Ok(())
}
main.swiftRepository
import Foundation
import Octridevvercel

@main
struct Example {
    static func main() async throws {
        let config = ClientConfig(
            // Optional: replaces the default server and any server an operation declares.
            baseUrl: "https://api.vercel.com",
            auth: ClientAuthConfig(bearerToken: ProcessInfo.processInfo.environment["API_TOKEN"]!)
        )
        let client = Vercel(config: config)
        let result = try await client.logDrains.getConfigurable(id: "id-1")
        print(result)
    }
}
Main.ktRepository
import dev.octri.showcase.vercel.*

fun main() {
    val config = ClientConfig(
        // Optional: replaces the default server and any server an operation declares.
        baseUrl = "https://api.vercel.com",
        auth = ClientAuthConfig(bearerToken = System.getenv("API_TOKEN")),
    )
    val client = Vercel(config)
    val result = client.logDrains.getConfigurable(id = "id-1")
    println(result)
}

Vercel

Deployments, projects, domains, log drains and the rest of the Vercel REST API.

Operations
458
Languages
10
VercelDocs
The Vercel docs site generated by Octri, showing the Aliases guide: dark scheme, full width layout, set in Geist.

Vercel docs

Vercel black in Geist and Geist Mono, with search in the sidebar and bordered rows running the full width of the window.

Layout
Full width
Typeface
Geist
Scheme
Dark
Settings
+34 more
DigitalOceanSDK
index.tsRepository
import { DigitalOcean } from "@octridev/digitalocean";

async function main() {
  const client = new DigitalOcean({
    // Optional: replaces the default server and any server an operation declares.
    baseUrl: "https://api.digitalocean.com",
    auth: { bearerAuth: process.env.API_TOKEN! },
  });
  const result = await client.apps.getInstances({ appId: "4f6c71e2-1e90-4762-9fee-6cc4a0a9f2cf" });
  console.log(result);
}

main().catch(console.error);
main.pyRepository
import os

from octridev_digitalocean import ClientConfig, ClientAuthConfig, DigitalOcean

config = ClientConfig(
    # Optional: replaces the default server and any server an operation declares.
    base_url="https://api.digitalocean.com",
    auth=ClientAuthConfig(bearer_auth=os.environ["API_TOKEN"]),
)
client = DigitalOcean(config)
result = client.apps.get_instances(app_id="4f6c71e2-1e90-4762-9fee-6cc4a0a9f2cf")
print(result)
main.goRepository
package main

import (
	"context"
	"fmt"
	"os"

	sdk "github.com/OctriDev/digitalocean-go-showcase-sdk"
)

func main() {
	ctx := context.Background()
	config := sdk.ClientConfig{
		// Optional: replaces the default server and any server an operation declares.
		BaseURL: "https://api.digitalocean.com",
		Auth: &sdk.ClientAuthConfig{BearerAuth: os.Getenv("API_TOKEN")},
	}
	client := sdk.NewDigitalOcean(config)
	result, err := client.Apps.GetInstances(ctx, sdk.AppsGetInstancesParams{AppId: "4f6c71e2-1e90-4762-9fee-6cc4a0a9f2cf"})
	if err != nil {
		panic(err)
	}
	fmt.Printf("%d instances\n", len(result.Instances))
}
Main.javaRepository
import dev.octri.showcase.digitalocean.*;
import dev.octri.showcase.digitalocean.methods.Apps;

public final class Example {
    public static void main(String[] args) throws Exception {
        var config = new SdkConfig.ClientConfig();
        // Optional: replaces the default server and any server an operation declares.
        config.baseUrl = "https://api.digitalocean.com";
        var auth = new SdkConfig.ClientAuthConfig();
        auth.bearerAuth = System.getenv("API_TOKEN");
        config.auth = auth;
        var client = new DigitalOcean(config);
        var result = client.apps.getInstances(Apps.AppsGetInstancesRequest.builder().appId("4f6c71e2-1e90-4762-9fee-6cc4a0a9f2cf").build());
        System.out.println(result);
    }
}
main.dartRepository
import 'dart:io';

import 'package:octridev_digitalocean/octridev_digitalocean.dart';

Future<void> main() async {
  final config = ClientConfig(
    // Optional: replaces the default server and any server an operation declares.
    baseUrl: "https://api.digitalocean.com",
    auth: ClientAuthConfig(bearerAuth: Platform.environment['API_TOKEN']!),
  );
  final client = DigitalOcean(config);
  final result = await client.apps.getInstances(appId: '4f6c71e2-1e90-4762-9fee-6cc4a0a9f2cf');
  print(result);
}
main.rbRepository
require "octridev_digitalocean"

config = OctridevDigitalocean::ClientConfig.new
# Optional: replaces the default server and any server an operation declares.
config.base_url = "https://api.digitalocean.com"
auth = OctridevDigitalocean::ClientAuthConfig.new
auth.bearer_auth = ENV.fetch("API_TOKEN")
config.auth = auth
client = OctridevDigitalocean::DigitalOcean.new(config)
result = client.apps.get_instances(app_id: "4f6c71e2-1e90-4762-9fee-6cc4a0a9f2cf")
p result
index.phpRepository
<?php

require __DIR__ . '/vendor/autoload.php';

use octridev_digitalocean\ClientConfig;
use octridev_digitalocean\SdkConfig;
use octridev_digitalocean\ClientAuthConfig;
use octridev_digitalocean\DigitalOcean;

$config = new ClientConfig();
// Optional: replaces the default server and any server an operation declares.
$config->baseUrl = "https://api.digitalocean.com";
$auth = new ClientAuthConfig();
$auth->bearerAuth = getenv('API_TOKEN') ?: throw new RuntimeException('API_TOKEN is required');
$config->auth = $auth;
$client = new DigitalOcean($config);
$result = $client->apps->getInstances(appId: "4f6c71e2-1e90-4762-9fee-6cc4a0a9f2cf");
var_dump($result);
main.rsRepository
use octridev_digitalocean::{ClientConfig, ClientAuthConfig, DigitalOcean};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let config = ClientConfig {
        // Optional: replaces the default server and any server an operation declares.
        base_url: Some("https://api.digitalocean.com".to_string()),
        auth: Some(ClientAuthConfig { bearer_auth: Some(std::env::var("API_TOKEN")?), ..Default::default() }),
        ..Default::default()
    };
    let client = DigitalOcean::new(config);
    let result = client.apps.get_instances("4f6c71e2-1e90-4762-9fee-6cc4a0a9f2cf".to_string(), None)?;
    println!("{result:#?}");
    Ok(())
}
main.swiftRepository
import Foundation
import Octridevdigitalocean

@main
struct Example {
    static func main() async throws {
        let config = ClientConfig(
            // Optional: replaces the default server and any server an operation declares.
            baseUrl: "https://api.digitalocean.com",
            auth: ClientAuthConfig(bearerAuth: ProcessInfo.processInfo.environment["API_TOKEN"]!)
        )
        let client = DigitalOcean(config: config)
        let result = try await client.apps.getInstances(appId: "4f6c71e2-1e90-4762-9fee-6cc4a0a9f2cf")
        print(result)
    }
}
Main.ktRepository
import dev.octri.showcase.digitalocean.*

fun main() {
    val config = ClientConfig(
        // Optional: replaces the default server and any server an operation declares.
        baseUrl = "https://api.digitalocean.com",
        auth = ClientAuthConfig(bearerAuth = System.getenv("API_TOKEN")),
    )
    val client = DigitalOcean(config)
    val result = client.apps.getInstances(appId = "4f6c71e2-1e90-4762-9fee-6cc4a0a9f2cf")
    println(result)
}

DigitalOcean

Droplets, Kubernetes, App Platform, databases and the rest of the DigitalOcean API.

Operations
855
Languages
10

DigitalOcean SDK repositories

DigitalOceanDocs

DigitalOcean docs

DigitalOcean blue under a navy top bar, the tabs starting where the framed column does, set in DM Sans with Dracula for code.

Layout
Framed
Typeface
DM Sans
Scheme
Light
Settings
+34 more
Visit the docs
NeonSDK
index.tsRepository
import { Neon } from "@octridev/neon";

async function main() {
  const client = new Neon({
    // Optional: replaces the default server and any server an operation declares.
    baseUrl: "https://console.neon.tech/api/v2",
    auth: { bearerAuth: process.env.API_TOKEN! },
  });
  const result = await client.branch.getMaskingRules({ projectId: "a", branchId: "a" });
  console.log(result);
}

main().catch(console.error);
main.pyRepository
import os

from octridev_neon import ClientConfig, ClientAuthConfig, Neon

config = ClientConfig(
    # Optional: replaces the default server and any server an operation declares.
    base_url="https://console.neon.tech/api/v2",
    auth=ClientAuthConfig(bearer_auth=os.environ["API_TOKEN"]),
)
client = Neon(config)
result = client.branch.get_masking_rules(project_id="a", branch_id="a")
print(result)
main.goRepository
package main

import (
	"context"
	"fmt"
	"os"

	sdk "github.com/OctriDev/neon-go-showcase-sdk"
)

func main() {
	ctx := context.Background()
	config := sdk.ClientConfig{
		// Optional: replaces the default server and any server an operation declares.
		BaseURL: "https://console.neon.tech/api/v2",
		Auth: &sdk.ClientAuthConfig{BearerAuth: os.Getenv("API_TOKEN")},
	}
	client := sdk.NewNeon(config)
	result, err := client.Branch.GetMaskingRules(ctx, sdk.GetMaskingRulesParams{ProjectId: "a", BranchId: "a"})
	if err != nil {
		panic(err)
	}
	fmt.Printf("%d masking_rules\n", len(result.MaskingRules))
}
Main.javaRepository
import dev.octri.showcase.neon.*;
import dev.octri.showcase.neon.methods.BranchApi;

public final class Example {
    public static void main(String[] args) throws Exception {
        var config = new SdkConfig.ClientConfig();
        // Optional: replaces the default server and any server an operation declares.
        config.baseUrl = "https://console.neon.tech/api/v2";
        var auth = new SdkConfig.ClientAuthConfig();
        auth.bearerAuth = System.getenv("API_TOKEN");
        config.auth = auth;
        var client = new Neon(config);
        var result = client.branch.getMaskingRules(BranchApi.GetMaskingRulesRequest.builder().projectId("a").branchId("a").build());
        System.out.println(result);
    }
}
main.dartRepository
import 'dart:io';

import 'package:octridev_neon/octridev_neon.dart';

Future<void> main() async {
  final config = ClientConfig(
    // Optional: replaces the default server and any server an operation declares.
    baseUrl: "https://console.neon.tech/api/v2",
    auth: ClientAuthConfig(bearerAuth: Platform.environment['API_TOKEN']!),
  );
  final client = Neon(config);
  final result = await client.branch.getMaskingRules(projectId: 'a', branchId: 'a');
  print(result);
}
main.rbRepository
require "octridev_neon"

config = OctridevNeon::ClientConfig.new
# Optional: replaces the default server and any server an operation declares.
config.base_url = "https://console.neon.tech/api/v2"
auth = OctridevNeon::ClientAuthConfig.new
auth.bearer_auth = ENV.fetch("API_TOKEN")
config.auth = auth
client = OctridevNeon::Neon.new(config)
result = client.branch.get_masking_rules(project_id: "a", branch_id: "a")
p result
index.phpRepository
<?php

require __DIR__ . '/vendor/autoload.php';

use octridev_neon\ClientConfig;
use octridev_neon\SdkConfig;
use octridev_neon\ClientAuthConfig;
use octridev_neon\Neon;

$config = new ClientConfig();
// Optional: replaces the default server and any server an operation declares.
$config->baseUrl = "https://console.neon.tech/api/v2";
$auth = new ClientAuthConfig();
$auth->bearerAuth = getenv('API_TOKEN') ?: throw new RuntimeException('API_TOKEN is required');
$config->auth = $auth;
$client = new Neon($config);
$result = $client->branch->getMaskingRules(projectId: "a", branchId: "a");
var_dump($result);
main.rsRepository
use octridev_neon::{ClientConfig, ClientAuthConfig, Neon};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let config = ClientConfig {
        // Optional: replaces the default server and any server an operation declares.
        base_url: Some("https://console.neon.tech/api/v2".to_string()),
        auth: Some(ClientAuthConfig { bearer_auth: Some(std::env::var("API_TOKEN")?), ..Default::default() }),
        ..Default::default()
    };
    let client = Neon::new(config);
    let result = client.branch.get_masking_rules("a".to_string(), "a".to_string(), None)?;
    println!("{result:#?}");
    Ok(())
}
main.swiftRepository
import Foundation
import Octridevneon

@main
struct Example {
    static func main() async throws {
        let config = ClientConfig(
            // Optional: replaces the default server and any server an operation declares.
            baseUrl: "https://console.neon.tech/api/v2",
            auth: ClientAuthConfig(bearerAuth: ProcessInfo.processInfo.environment["API_TOKEN"]!)
        )
        let client = Neon(config: config)
        let result = try await client.branch.getMaskingRules(projectId: "a", branchId: "a")
        print(result)
    }
}
Main.ktRepository
import dev.octri.showcase.neon.*

fun main() {
    val config = ClientConfig(
        // Optional: replaces the default server and any server an operation declares.
        baseUrl = "https://console.neon.tech/api/v2",
        auth = ClientAuthConfig(bearerAuth = System.getenv("API_TOKEN")),
    )
    val client = Neon(config)
    val result = client.branch.getMaskingRules(projectId = "a", branchId = "a")
    println(result)
}

Neon

Projects, branches, databases, roles and the rest of the Neon management API.

Operations
192
Languages
10
NeonDocs

Neon docs

Neon green on near-black in IBM Plex Sans, with square corners and the tabs stacked under the logo.

Layout
Contained
Typeface
IBM Plex Sans
Scheme
Dark
Settings
+34 more
Visit the docs
IntercomSDK
index.tsRepository
import { Intercom } from "@octridev/intercom";

async function main() {
  const client = new Intercom({
    // Optional: replaces the default server and any server an operation declares.
    baseUrl: "https://api.intercom.io",
    auth: { bearerAuth: process.env.API_TOKEN! },
  });
  const result = await client.contentSnippets.get({ id: "123" });
  console.log(result);
}

main().catch(console.error);
main.pyRepository
import os

from octridev_intercom import ClientConfig, ClientAuthConfig, Intercom

config = ClientConfig(
    # Optional: replaces the default server and any server an operation declares.
    base_url="https://api.intercom.io",
    auth=ClientAuthConfig(bearer_auth=os.environ["API_TOKEN"]),
)
client = Intercom(config)
result = client.content_snippets.get(id="123")
print(result)
main.goRepository
package main

import (
	"context"
	"fmt"
	"os"

	sdk "github.com/OctriDev/intercom-go-showcase-sdk"
)

func main() {
	ctx := context.Background()
	config := sdk.ClientConfig{
		// Optional: replaces the default server and any server an operation declares.
		BaseURL: "https://api.intercom.io",
		Auth: &sdk.ClientAuthConfig{BearerAuth: os.Getenv("API_TOKEN")},
	}
	client := sdk.NewIntercom(config)
	result, err := client.ContentSnippets.Get(ctx, sdk.GetContentSnippetParams{Id: "123"})
	if err != nil {
		panic(err)
	}
	fmt.Printf("%d json_blocks\n", len(result.JsonBlocks))
}
Main.javaRepository
import dev.octri.showcase.intercom.*;
import dev.octri.showcase.intercom.methods.ContentSnippets;

public final class Example {
    public static void main(String[] args) throws Exception {
        var config = new SdkConfig.ClientConfig();
        // Optional: replaces the default server and any server an operation declares.
        config.baseUrl = "https://api.intercom.io";
        var auth = new SdkConfig.ClientAuthConfig();
        auth.bearerAuth = System.getenv("API_TOKEN");
        config.auth = auth;
        var client = new Intercom(config);
        var result = client.contentSnippets.get(ContentSnippets.GetContentSnippetRequest.builder().id("123").build());
        System.out.println(result);
    }
}
main.dartRepository
import 'dart:io';

import 'package:octridev_intercom/octridev_intercom.dart';

Future<void> main() async {
  final config = ClientConfig(
    // Optional: replaces the default server and any server an operation declares.
    baseUrl: "https://api.intercom.io",
    auth: ClientAuthConfig(bearerAuth: Platform.environment['API_TOKEN']!),
  );
  final client = Intercom(config);
  final result = await client.contentSnippets.get_(id: '123');
  print(result);
}
main.rbRepository
require "octridev_intercom"

config = OctridevIntercom::ClientConfig.new
# Optional: replaces the default server and any server an operation declares.
config.base_url = "https://api.intercom.io"
auth = OctridevIntercom::ClientAuthConfig.new
auth.bearer_auth = ENV.fetch("API_TOKEN")
config.auth = auth
client = OctridevIntercom::Intercom.new(config)
result = client.content_snippets.get(id: "123")
p result
index.phpRepository
<?php

require __DIR__ . '/vendor/autoload.php';

use octridev_intercom\ClientConfig;
use octridev_intercom\SdkConfig;
use octridev_intercom\ClientAuthConfig;
use octridev_intercom\Intercom;

$config = new ClientConfig();
// Optional: replaces the default server and any server an operation declares.
$config->baseUrl = "https://api.intercom.io";
$auth = new ClientAuthConfig();
$auth->bearerAuth = getenv('API_TOKEN') ?: throw new RuntimeException('API_TOKEN is required');
$config->auth = $auth;
$client = new Intercom($config);
$result = $client->contentSnippets->get(id: "123");
var_dump($result);
main.rsRepository
use octridev_intercom::{ClientConfig, ClientAuthConfig, Intercom};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let config = ClientConfig {
        // Optional: replaces the default server and any server an operation declares.
        base_url: Some("https://api.intercom.io".to_string()),
        auth: Some(ClientAuthConfig { bearer_auth: Some(std::env::var("API_TOKEN")?), ..Default::default() }),
        ..Default::default()
    };
    let client = Intercom::new(config);
    let result = client.content_snippets.get("123".to_string(), None, None)?;
    println!("{result:#?}");
    Ok(())
}
main.swiftRepository
import Foundation
import Octridevintercom

@main
struct Example {
    static func main() async throws {
        let config = ClientConfig(
            // Optional: replaces the default server and any server an operation declares.
            baseUrl: "https://api.intercom.io",
            auth: ClientAuthConfig(bearerAuth: ProcessInfo.processInfo.environment["API_TOKEN"]!)
        )
        let client = Intercom(config: config)
        let result = try await client.contentSnippets.get(id: "123")
        print(result)
    }
}
Main.ktRepository
import dev.octri.showcase.intercom.*

fun main() {
    val config = ClientConfig(
        // Optional: replaces the default server and any server an operation declares.
        baseUrl = "https://api.intercom.io",
        auth = ClientAuthConfig(bearerAuth = System.getenv("API_TOKEN")),
    )
    val client = Intercom(config)
    val result = client.contentSnippets.get(id = "123")
    println(result)
}

Intercom

Conversations, contacts, articles, tickets and the rest of the Intercom API.

Operations
258
Languages
10
IntercomDocs

Intercom docs

Deep teal on white in Figtree, with square corners, a transparent top bar and search at the head of a bordered sidebar.

Layout
Floating
Typeface
Figtree
Scheme
Light
Settings
+34 more
Visit the docs

Each sample is generated from the API owner's publicly available OpenAPI document and published as unofficial source on GitHub. None of it is on a package registry. None of these companies is an Octri customer or endorses Octri, and the names and logos remain their owners' trademarks.

Now run your own spec

The Free plan publishes a real docs site and one SDK from your OpenAPI document, with monitoring included.