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

# Developer console map: every developer-hub tile on one page

> One orientation page for the dashboard's Developer hub — the question that brings you here, what the hub lays out, one paragraph per console tile, and the deep-dive guides behind each.

# Developer console map

The dashboard's **Developer** hub (`/developer`) collects every surface an
integration touches in one tile grid — sandbox, API keys, playground, GraphQL,
Postman, MCP, QR tools, network APIs, and the rest. This page is the map of
that grid: it states the problem the hub answers, enumerates the tiles as
they ship today, and gives each one a one-paragraph read so discovery takes a
single page instead of twenty clicks. Per-console walkthroughs stay where
they belong — in the linked deep-dive guides.

## The problem the hub answers

An Orbit integration spans surfaces that otherwise drift apart: the key
console lives in Settings, the request builder is a form, delivery evidence
is a log, event fan-out is a sink config, and the AI-assistant entry point is
an MCP handshake. The hub exists so a developer answering "where do I…" never
hunts the sidebar. Above the grid, four computed cards summarize the
workspace — API calls today, average latency, request success rate, and
active keys — so the same page doubles as the quickest health check before
you drill in. (Reading those cards is covered in [Developer hub overview
cards](/guides/developer-overview-page); the full role-gated tour of the hub
lives in [Tour the Developer hub](/guides/developer-hub-overview).)

## Hub layout

Open the dashboard and choose **Developer**; owner, admin, and developer
roles see the entry. The landing page renders four KPI cards, then the tile
grid below. Each tile links one route deeper under `/developer` (API Keys
opens the shared console in Settings):

| Tile                  | Route                                               |
| --------------------- | --------------------------------------------------- |
| API Reference         | `/developer/api-reference`                          |
| SDKs & Libraries      | `/developer/sdks`                                   |
| Webhook Tester        | `/developer/webhook-tester`                         |
| API Keys              | `/settings/api-keys` (opens the shared key console) |
| Request Logs          | `/developer/request-logs`                           |
| Delivery Logs         | `/developer/delivery-logs`                          |
| QR Code Tools         | `/developer/qr-tools`                               |
| SDK Live Demo         | `/developer/sdk-demo`                               |
| Video Room Embed Demo | `/developer/video-embed-demo`                       |
| API Analytics         | `/developer/api-analytics`                          |
| Rate Limits & Quotas  | `/developer/api-governance`                         |
| Postman Collection    | `/developer/postman`                                |
| GraphQL Explorer      | `/developer/graphql`                                |
| Connectors            | `/developer/connectors`                             |
| Connected Apps        | `/developer/connected-apps`                         |
| MCP Server            | `/developer/mcp`                                    |
| Webhook Deliveries    | `/developer/webhooks`                               |
| Event Streaming Sinks | `/developer/event-sinks`                            |
| Event Sources         | `/developer/event-sources`                          |
| SMPP Credentials      | `/developer/smpp`                                   |
| SMTP Relay            | `/developer/smtp`                                   |
| Sandbox               | `/developer/sandbox`                                |
| Sync Explorer         | `/developer/sync`                                   |
| API Playground        | `/developer/playground`                             |
| Network APIs          | `/developer/network-apis`                           |
| Marketplace           | `/developer/marketplace`                            |

A right-hand quickstart card anchors the page with the three-step on-ramp —
create a key, install an SDK, send a message — plus a copyable `curl` sample.

## What each tile reads

One paragraph per tile. The question in bold is the one that brings you here.

**API Reference** — *what does the endpoint accept and return?* The
in-product REST reference with interactive examples for SMS, Voice, WhatsApp,
and the other channels. Start here when you know the feature but not the
exact request shape; the [developer portal](/guides/developer-portal) guide
maps the portal surface this page is built on.

**SDKs & Libraries** — *install what, from where?* The official client
catalog: Node.js and web SDKs are generally available, with Python, Go, Java,
.NET, Ruby, and PHP on the roadmap. Each entry carries the package name and
install command; [Integrate with the REST API](/guides/api-integration) walks
the surface level end to end.

**Webhook Tester** — *will my endpoint accept a real event?* Fires a test
webhook event at your URL and shows the exact request your server received
and the response it sent back. Use it before pointing production traffic at a
new consumer; [Test webhooks with the Webhook Tester](/guides/webhook-tester)
covers signature inspection and replay.

**API Keys** — *mint, scope, rotate.* Creates and manages keys with granular
scoping and per-key rate-limit configuration; the tile and the hub's "Create
API key" button both land on the shared console under **Settings → API Keys**.
[Choosing scopes](/guides/api-keys-messaging-ccaas-cdp),
[IP allowlist per key](/guides/api-key-ip-allowlist), and
[usage limits per key](/guides/api-key-usage-limits) cover the hardening.

**Request Logs** — *did my call arrive, and what came back?* Every API
request your workspace makes, with timing, payloads, and status codes, plus
filters and a live tail. First stop for any "my integration failed" report;
the [Request Logs console](/guides/api-request-logs-console) guide details
the filters and the per-request drill-down.

**Delivery Logs** — *the send succeeded — did it land?* Searches every
outbound and inbound message across channels, correlated by message ID, with
the carrier delivery code per leg. First stop for "sent but not delivered";
[Delivery Logs console](/guides/developer-delivery-logs) shows how to carry
the rejection reason into a ticket.

**QR Code Tools** — *a scan-to-chat link, no build step.* Generates QR codes
for SMS, WhatsApp, or arbitrary URLs so a printed code opens a pre-filled
message. [QR Code Tools](/guides/qr-tools) covers the per-channel formats.

**SDK Live Demo** — *does browser calling work end to end?* Dials a real test
call through the web SDK's Softphone class — the canonical integration
example you can copy line for line. [Browser softphone demo](/guides/sdk-demo-browser-softphone)
walks the flow.

**Video Room Embed Demo** — *embed a video room in a page.* Joins a tenant
video room through the published web SDK's video widget inside the dashboard,
then hands you the embed snippet. [Video Room Embed Demo](/guides/developer-video-embed-demo)
covers the widget parameters.

**API Analytics** — *which key or endpoint moved the numbers?* Read-only
per-endpoint volume, error rate, latency percentiles, and rate-limit hits,
with per-key attribution — the one hub surface a viewer role may also read.
[API analytics dashboards](/guides/api-analytics-reader) details the reads.

**Rate Limits & Quotas** — *set the ceiling before traffic lands.* The API
governance console: an org-wide default request rate and monthly quota, plus
per-key overrides read against live usage headroom — changes apply instantly.
[API governance console](/guides/developer-api-governance-console) and
[rate limits console](/guides/api-rate-limits-console) cover the model.

**Postman Collection** — *move the request into a team-owned artifact.*
Downloads a Postman collection and environment pre-wired with your base URL
and organization ID. [Postman collections & recipes](/guides/postman-collections-recipes)
covers environments per stage and CI wiring; the [playground](#playground-graphql-mcp-the-try-surfaces)
comparison below helps you pick.

**GraphQL Explorer** — *a tree of related records in one request.* Queries
contacts, conversations, messages, and segments — shaped reads that would
otherwise be several REST round-trips. [Query with GraphQL](/guides/graphql-querying)
walks the schema and explorer.

**Connectors** — *Orbit in your no-code stack.* Downloads a Zapier or Make
custom app pre-wired to your tenant, so no-code triggers and actions can call
the platform. [Connector downloads](/guides/connectors-download) covers
installation.

**Connected Apps** — *let customers grant your app scoped access.* The OAuth
marketplace surface: download the client-registration manifest, review the
scope catalog a customer can grant, and preview the consent screen.
[Connected Apps with OAuth](/guides/connected-apps) covers the publish flow.

**MCP Server** — *hand the platform to your AI assistant.* Orbit as
LLM-consumable tools: test the initialize handshake and list the tool catalog
your API key's scopes unlock. [MCP in Claude / Cursor](/guides/mcp-claude-cursor)
connects the editor; [MCP handshake](/guides/mcp-server-handshake) covers the
transport.

**Webhook Deliveries** — *did the event reach your endpoint?* Per-endpoint
delivery logs, retry state, and signature verification for your outbound
webhook subscriptions. First stop when a consumer misses events;
[Operate a webhook endpoint](/guides/webhook-endpoint-operations) covers
rotating secrets and replaying deliveries.

**Event Streaming Sinks** — *fan the whole event taxonomy into your stack.*
Streams platform events to a destination you run — a Kafka topic or a batch
HTTP collector — with brokers, topic, and encrypted credentials per sink.
[Configure event sinks](/guides/event-sinks-streaming) and
[first sink deployment](/guides/event-sink-first-deployment) walk the setup.

**Event Sources** — *pull your own Kafka topic into Orbit.* The inbound
mirror of sinks: set brokers, topic, consumer group, and encrypted
credentials, then dry-run a sample batch against the subscription's type
mapping. [Configure event sources](/guides/event-sources-inbound) covers the
contract.

**SMPP Credentials** — *bring your own SMPP client.* Issues credentials,
rotates passwords, and shows the connection host/port for binding an external
SMPP client to Orbit's SMPP edge. [Connect via SMPP](/guides/smpp) covers the
bind lifecycle.

**SMTP Relay** — *send email from any SMTP client.* Connection details for
the authenticated relay — authenticate with the username `apikey` and an API
key as the password; tagged early access while the edge rolls out.
[SMTP relay recipes](/guides/smtp-relay-recipes) covers client configs.

**Sandbox** — *exercise the platform with no carrier spend.* Test mode:
test API keys, a default test recipient, per-channel stub status, provisioned
fixture numbers, and a reset — so you can run the whole flow before any
billing. [Sandbox and test mode](/guides/sandbox-test-mode) explains the
model; [Operate the Sandbox dashboard](/guides/sandbox-dashboard-walkthrough)
is the full console walkthrough.

**Sync Explorer** — *inspect the shared real-time state.* Reads and edits the
durable primitives — Documents, Maps, Lists, and Streams — backing
collaboration and presence features. [Sync end to end](/guides/sync-realtime-state)
covers the object model.

**API Playground** — *build and send a request without leaving the
dashboard.* An interactive request builder: pick an endpoint, fill the form,
preview the generated curl/SDK code, and send against your live account —
the call lands in Request Logs like any integration traffic.
[API playground](/guides/developer-api-playground) and its
[tutorial](/guides/developer-api-playground-tutorial) walk the loop.

**Network APIs** — *operator-asserted identity signals.* GSMA Open Gateway /
CAMARA surfaces — Number Verification, SIM Swap, and KYC Match — with
early-access registration ahead of launch. [Network signals before you send](/guides/network-signals-open-gateway)
covers the registration path.

**Marketplace** — *install a template, or publish one.* Browses and installs
flow templates, integrations, and agent templates into your workspace, or
submits your own for review. [Browse, install, and publish](/guides/marketplace-browse-install-publish)
covers both sides.

## Playground, GraphQL, MCP: the try surfaces

Three tiles overlap in "make the platform do something now" and differ in
where the artifact lives. The **Playground** keeps the work in the dashboard
— reproduce a failing call and read the result in Request Logs. **Postman**
moves the same requests into an artifact your team owns and versions.
**GraphQL** collapses multi-resource reads into a single shaped query when
REST would round-trip. **MCP** hands the same capabilities to an AI assistant
under your key's scopes — every tool call still lands in Request Logs. Pick
the surface by who keeps the result: you (playground), your team (Postman),
your query layer (GraphQL), or your assistant (MCP).

## Deep-dive guides

* [Tour the Developer hub](/guides/developer-hub-overview) — the role-gated
  tour and suggested setup order
* [Developer hub overview cards](/guides/developer-overview-page) — the KPI
  cards at the top of the hub
* [Operate the Sandbox dashboard](/guides/sandbox-dashboard-walkthrough) —
  the sandbox console end to end
* [MCP in Claude / Cursor](/guides/mcp-claude-cursor) — connect your editor
  or agent
* [Postman collections & recipes](/guides/postman-collections-recipes) — the
  team-ownable request artifact
* [Query with GraphQL](/guides/graphql-querying) — shaped reads against the
  explorer
* [API governance console](/guides/developer-api-governance-console) — rate
  limits and quotas
* [API analytics dashboards](/guides/api-analytics-reader) — the read-only
  numbers the hub summarizes