Package Exports

orbisapi-sdk

Readme

orbis-sdk

Official JavaScript/TypeScript SDK for the Orbis API Marketplace — the API marketplace built for the agent era.

Browse, subscribe to, and call 65+ production APIs from any AI agent — no human in the loop required.

npm install orbis-sdk

What is Orbis?

Orbis is an API marketplace where AI agents can:

Browse 65+ APIs across categories
Subscribe and get a live API key in a single call (free tiers instant, paid via Stripe)
Pay per call using USDC on Base via the x402 protocol — no subscription needed
Discover via MCP at https://orbisapi.com/api/mcp

Platform fee: 10%. Providers keep 90%.

Quick Start

import { OrbisClient } from "orbis-sdk";

const orbis = new OrbisClient();

// One-shot: browse → register → subscribe → get API key
const { apiKey, usage } = await orbis.quickSubscribe({
  email: "my-agent@example.com",
  password: "secure-pass-123",
  username: "my-agent",
  apiSlug: "text-utilities",
});

// Call the API with your key
const res = await fetch(usage.baseUrl, {
  headers: { "x-api-key": apiKey.key },
});
console.log(await res.json());

LangChain Integration

import { createLangChainTools } from "orbis-sdk";
import { DynamicTool } from "@langchain/core/tools";
import { ChatOpenAI } from "@langchain/openai";
import { AgentExecutor, createOpenAIFunctionsAgent } from "langchain/agents";

const creds = {
  email: "my-agent@example.com",
  password: "secure-pass-123",
  username: "my-langchain-agent",
};

// Create Orbis tools — browse_apis, subscribe_to_api, call_api
const defs = createLangChainTools({ credentials: creds });
const tools = defs.map(d => new DynamicTool(d));

const llm = new ChatOpenAI({ modelName: "gpt-4o" });
const agent = await createOpenAIFunctionsAgent({ llm, tools, prompt });
const executor = AgentExecutor.fromAgentAndTools({ agent, tools });

const result = await executor.invoke({
  input: "Find a text processing API on Orbis, subscribe to it, and analyze this sentence: 'AI agents are the future.'"
});

Three tools available:

Tool	Description
`orbis_browse_apis`	Browse the full catalogue with slugs, pricing, and tier IDs
`orbis_subscribe_to_api`	Subscribe to any API by slug and get a live API key
`orbis_call_api`	Make HTTP requests to any Orbis API endpoint

OpenAI Function Calling / CrewAI

import { createOpenAITools } from "orbis-sdk";
import OpenAI from "openai";

const { tools, handlers } = createOpenAITools({
  credentials: {
    email: "my-agent@example.com",
    password: "secure-pass-123",
    username: "my-agent",
  },
});

const openai = new OpenAI();

const response = await openai.chat.completions.create({
  model: "gpt-4o",
  messages: [{ role: "user", content: "Subscribe to the QR code API on Orbis and generate a QR code for https://orbisapi.com" }],
  tools,
  tool_choice: "auto",
});

// Handle tool calls
for (const toolCall of response.choices[0].message.tool_calls ?? []) {
  const args = JSON.parse(toolCall.function.arguments);
  const result = await handlers[toolCall.function.name](args);
  console.log(result);
}

CrewAI (Python) — via REST

import requests

# 1. Browse
catalogue = requests.get("https://orbisapi.com/api/agents/discovery?_raw=1").json()

# 2. Subscribe
result = requests.post("https://orbisapi.com/api/agents/subscribe", json={
    "email": "my-agent@example.com",
    "password": "secure-pass-123",
    "tierId": catalogue["catalogue"][0]["tiers"][0]["id"],
}).json()

api_key = result["apiKey"]["key"]
base_url = result["usage"]["baseUrl"]

# 3. Call
response = requests.get(base_url, headers={"x-api-key": api_key})
print(response.json())

Eliza Plugin

import { createElizaActions } from "orbis-sdk";

const actions = createElizaActions({
  credentials: {
    email: "eliza-agent@example.com",
    password: "secure-pass-123",
    username: "eliza-crew",
  },
});

// Register with your Eliza runtime
actions.forEach(action => runtime.registerAction(action));

// Actions registered:
// - ORBIS_BROWSE_APIS   — triggered when user asks about available APIs
// - ORBIS_SUBSCRIBE_API — triggered when user asks to subscribe to an API

OpenClaw

OpenClaw agents use the MCP endpoint — no custom adapter needed:

{
  "mcpServers": {
    "orbis": { "url": "https://orbisapi.com/api/mcp" }
  }
}

Or drop ORBIS-SKILL.md (included in this package) directly into your OpenClaw agent's skill directory. It teaches the agent the full discover → subscribe → call flow in plain Markdown — no code required.

x402 Pay-per-call (No subscription needed)

For EVM agents using Coinbase AgentKit or any Base wallet — agents pay USDC on Base per call, no subscription or API key required:

import { wrapFetchWithPayment } from "x402-fetch";
import { createWalletClient, http } from "viem";
import { privateKeyToAccount } from "viem/accounts";
import { base } from "viem/chains";

const account = privateKeyToAccount(process.env.PRIVATE_KEY as `0x${string}`);
const walletClient = createWalletClient({ account, chain: base, transport: http() });
const fetch = wrapFetchWithPayment(globalThis.fetch, walletClient);

// Agent pays USDC on Base automatically — no key management
const response = await fetch("https://orbisapi.com/text-api/analyze");
const data = await response.json();

MCP (Model Context Protocol)

Connect any MCP-compatible client directly — Claude Desktop, Cursor, or any agent framework:

{
  "mcpServers": {
    "orbis": {
      "url": "https://orbisapi.com/api/mcp"
    }
  }
}

Tools exposed via MCP: browse_apis, register_agent, subscribe_to_api

Full API Reference

`OrbisClient`

const orbis = new OrbisClient({ baseUrl?: string });

orbis.browse()                                          // Full catalogue
orbis.register({ email, password, username })           // Register agent account
orbis.subscribe({ email, password, tierId })            // Subscribe + get API key
orbis.quickSubscribe({ email, password, username, apiSlug }) // All-in-one
orbis.freeApis()                                        // APIs with free tiers only

Framework helpers

createLangChainTools(options)  // → LangChainToolDef[]  (wrap in DynamicTool)
createOpenAITools(options)     // → { tools, handlers }  (OpenAI function calling)
createElizaActions(options)    // → ElizaAction[]        (register with runtime)

JSPM

orbisapi-sdk