USSD API

USSD (Unstructured Supplementary Service Data) is the menu-over-dial-code channel for feature phones. A subscriber dials a short code such as *384*1#, the mobile network opens a synchronous session and posts each keypress to your application, and the application replies with the next screen. It needs no data plan, which makes it the reach channel for markets where a large share of devices are 2G feature phones. Orbit hosts the menu and the session engine for you. You configure a menu tree once, point your aggregator (for example Africa’s Talking) at the tenant-scoped callback, and Orbit resolves each step. Base path: /api/v1/ussd Authentication: API key (X-API-Key) or session JWT — except the aggregator callback, which is a public, tenant-scoped webhook.

Using the SDKs

The samples below exercise the endpoints this page documents — create or replace a menu, preview a step with the simulator, and fetch the saved menu — in every language the page claims. Node and Python use the SDK escape-hatch request(), which keeps auth/retries and the { data, meta } envelope identical while it reaches endpoints the typed helpers don’t wrap yet. Go, Ruby, and PHP use plain HTTP clients (no SDK dependency) against the same endpoints. This same menu tree appears throughout the page: a root screen, one branch, and one terminal node.

# 1. Create or replace the menu
curl -X PUT "https://api.orbit.devotel.io/api/v1/ussd/menu" \
  -H "X-API-Key: $ORBIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "serviceCode": "*384*1#",
    "root": "main",
    "nodes": [
      {
        "id": "main",
        "prompt": "Welcome to Acme",
        "options": [
          { "key": "1", "label": "Check balance", "next": "balance" }
        ]
      },
      { "id": "balance", "prompt": "Your balance is 250.00" }
    ]
  }'

# 2. Preview a step against the saved menu
curl -X POST "https://api.orbit.devotel.io/api/v1/ussd/simulate" \
  -H "X-API-Key: $ORBIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "text": "1" }'

# 3. Fetch the saved menu
curl "https://api.orbit.devotel.io/api/v1/ussd/menu" \
  -H "X-API-Key: $ORBIT_API_KEY"

import { Orbit } from "@devotel-orbit/node";

const orbit = new Orbit({ apiKey: process.env.ORBIT_API_KEY! });

const menu = {
  serviceCode: "*384*1#",
  root: "main",
  nodes: [
    {
      id: "main",
      prompt: "Welcome to Acme",
      options: [{ key: "1", label: "Check balance", next: "balance" }],
    },
    { id: "balance", prompt: "Your balance is 250.00" },
  ],
};

const { data: saved } = await orbit.request<unknown>("PUT", "/ussd/menu", menu);
const { data: step } = await orbit.request<unknown>("POST", "/ussd/simulate", {
  text: "1",
});
const { data: current } = await orbit.request<unknown>("GET", "/ussd/menu");
console.log(saved, step, current);

from orbit_sdk import OrbitClient

client = OrbitClient.from_env()  # reads ORBIT_API_KEY

menu = {
    "serviceCode": "*384*1#",
    "root": "main",
    "nodes": [
        {
            "id": "main",
            "prompt": "Welcome to Acme",
            "options": [
                {"key": "1", "label": "Check balance", "next": "balance"}
            ],
        },
        {"id": "balance", "prompt": "Your balance is 250.00"},
    ],
}

saved = client.request("PUT", "/ussd/menu", menu)
step = client.request("POST", "/ussd/simulate", {"text": "1"})
current = client.request("GET", "/ussd/menu")
print(saved["data"], step["data"], current["data"])

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"net/http"
	"os"
)

func main() {
	menu := map[string]any{
		"serviceCode": "*384*1#",
		"root":        "main",
		"nodes": []map[string]any{
			{
				"id":    "main",
				"prompt": "Welcome to Acme",
				"options": []map[string]any{
					{"key": "1", "label": "Check balance", "next": "balance"},
				},
			},
			{"id": "balance", "prompt": "Your balance is 250.00"},
		},
	}
	body, _ := json.Marshal(menu)

	req, _ := http.NewRequest("PUT", "https://api.orbit.devotel.io/api/v1/ussd/menu", bytes.NewReader(body))
	req.Header.Set("X-API-Key", os.Getenv("ORBIT_API_KEY"))
	req.Header.Set("Content-Type", "application/json")
	res, _ := http.DefaultClient.Do(req)
	fmt.Println(res.Status)

	stepBody, _ := json.Marshal(map[string]string{"text": "1"})
	req2, _ := http.NewRequest("POST", "https://api.orbit.devotel.io/api/v1/ussd/simulate", bytes.NewReader(stepBody))
	req2.Header.Set("X-API-Key", os.Getenv("ORBIT_API_KEY"))
	req2.Header.Set("Content-Type", "application/json")
	res2, _ := http.DefaultClient.Do(req2)
	fmt.Println(res2.Status)

	req3, _ := http.NewRequest("GET", "https://api.orbit.devotel.io/api/v1/ussd/menu", nil)
	req3.Header.Set("X-API-Key", os.Getenv("ORBIT_API_KEY"))
	res3, _ := http.DefaultClient.Do(req3)
	fmt.Println(res3.Status)
}

require 'json'
require 'net/http'

BASE = 'https://api.orbit.devotel.io/api/v1'
KEY  = ENV['ORBIT_API_KEY']

menu = {
  serviceCode: '*384*1#',
  root: 'main',
  nodes: [
    {
      id: 'main',
      prompt: 'Welcome to Acme',
      options: [{ key: '1', label: 'Check balance', next: 'balance' }],
    },
    { id: 'balance', prompt: 'Your balance is 250.00' },
  ],
}

def call(klass, path, key, body = nil)
  uri = URI("#{BASE}#{path}")
  req = klass.new(uri)
  req['X-API-Key'] = key
  if body
    req['Content-Type'] = 'application/json'
    req.body = JSON.dump(body)
  end
  Net::HTTP.start(uri.host, uri.port, use_ssl: true) { |h| h.request(req) }
end

resput = call(Net::HTTP::Put, '/ussd/menu', KEY, menu)
respost = call(Net::HTTP::Post, '/ussd/simulate', KEY, { text: '1' })
resget = call(Net::HTTP::Get, '/ussd/menu', KEY)
puts resput.body, respost.body, resget.body

<?php
$key = getenv('ORBIT_API_KEY');

$menu = [
  'serviceCode' => '*384*1#',
  'root'        => 'main',
  'nodes'       => [
    [
      'id'     => 'main',
      'prompt' => 'Welcome to Acme',
      'options' => [['key' => '1', 'label' => 'Check balance', 'next' => 'balance']],
    ],
    ['id' => 'balance', 'prompt' => 'Your balance is 250.00'],
  ],
];

function call_api(string $method, string $path, string $key, ?array $body = null): string {
  $ch = curl_init("https://api.orbit.devotel.io/api/v1{$path}");
  curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
  curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
  $headers = ['X-API-Key: ' . $key];
  if ($body !== null) {
    $headers[] = 'Content-Type: application/json';
    curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($body));
  }
  curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
  return curl_exec($ch);
}

echo call_api('PUT', '/ussd/menu', $key, $menu);
echo call_api('POST', '/ussd/simulate', $key, ['text' => '1']);
echo call_api('GET', '/ussd/menu', $key);

The Python SDK is core-scope — it wraps the 8 core resources (messaging, voice, contacts, campaigns, verify, numbers) and reaches everything else through the generic client.request() escape hatch above. See the Python SDK. The push flow (PUT /api/v1/ussd/push/config then POST /api/v1/ussd/push) follows the same pattern — swap the path and body from the curl sample in Configure the push provider below. The aggregator callback is deliberately excluded: it is a public webhook you point your aggregator dashboard at, so it stays curl-only. Raw curl in the body of this page works identically. Full SDK index at SDK quickstart.

How a session works

The engine speaks the de-facto African-aggregator protocol. On every step the aggregator sends the full accumulated input string, with each prior keypress joined by * (the initial dial is an empty string). Orbit replies with a plain-text body whose first token is:

CON — show the message and keep the session open for more input.
END — show the message and terminate the session.

Because the aggregator replays the entire input chain on each callback, the engine is stateless: the next screen is a deterministic function of (menu, accumulated input). There is no per-session storage to manage.

Endpoints

Method	Path	Auth	Purpose
`GET`	`/api/v1/ussd/menu`	API key / JWT	Fetch the tenant’s configured menu
`PUT`	`/api/v1/ussd/menu`	`owner` · `admin` · `developer`	Create or replace the menu
`POST`	`/api/v1/ussd/simulate`	API key / JWT	Preview a session step
`GET`	`/api/v1/ussd/push/config`	API key / JWT	Fetch the push-provider config
`PUT`	`/api/v1/ussd/push/config`	`owner` · `admin` · `developer`	Create or replace the push-provider config
`POST`	`/api/v1/ussd/push`	`owner` · `admin` · `developer`	Open a network-initiated (push) session
`POST`	`/api/v1/ussd/callback/{tenantId}`	Public webhook	Aggregator session callback

A menu is a tree of nodes (screens) navigated from a root node. Each branch node lists numbered options; a node with no options (or final: true) terminates the session.

Field	Type	Notes
`serviceCode`	string	Optional dial code this menu answers (documentation only, e.g. `3841#`).
`root`	string	Id of the node shown on the initial dial. Must reference an existing node.
`nodes`	array	1–200 screens. Must include `root`.
`nodes[].id`	string	Stable node id (≤ 64 chars), referenced by `root` and option `next`. Must be unique.
`nodes[].prompt`	string	Screen text (≤ 160 chars).
`nodes[].options`	array	Up to 12 branch options. Omit for a terminal screen.
`nodes[].options[].key`	string	Input token the subscriber types (digits, letters, `#` or `*`; ≤ 8 chars).
`nodes[].options[].label`	string	Label rendered next to the key.
`nodes[].options[].next`	string	Id of the node this option navigates to. Must resolve to an existing node.
`nodes[].final`	boolean	Force the node to end the session even if it has options.

On PUT /menu the tree is validated for unique node ids and that root plus every option next resolves to an existing node; the request is rejected otherwise. A successful write replaces any previously configured menu.

curl -X PUT https://api.orbit.devotel.io/api/v1/ussd/menu \
  -H "X-API-Key: dv_live_sk_your_key_here" \
  -H "Content-Type: application/json" \
  -d '{
    "serviceCode": "*384*1#",
    "root": "main",
    "nodes": [
      {
        "id": "main",
        "prompt": "Welcome to Acme",
        "options": [
          { "key": "1", "label": "Check balance", "next": "balance" },
          { "key": "2", "label": "Buy airtime", "next": "airtime" }
        ]
      },
      { "id": "balance", "prompt": "Your balance is 250.00" },
      { "id": "airtime", "prompt": "Airtime top-up is coming soon." }
    ]
  }'

The configured menu is returned under data.menu. GET /api/v1/ussd/menu returns the same shape, or data.menu: null when none has been configured yet.

Simulate a session step

Run the live engine against an input string without touching your aggregator — useful while building and testing menus. Pass an inline menu to preview an unsaved definition; omit it to use the tenant’s configured menu.

Field	Type	Notes
`text`	string	Accumulated input, `*`-joined (empty or omitted for the initial dial).
`menu`	object	Optional inline menu to preview instead of the saved one.

curl -X POST https://api.orbit.devotel.io/api/v1/ussd/simulate \
  -H "X-API-Key: dv_live_sk_your_key_here" \
  -H "Content-Type: application/json" \
  -d '{ "text": "1" }'

{
  "data": {
    "action": "END",
    "message": "Your balance is 250.00",
    "node_id": "balance",
    "raw": "END Your balance is 250.00"
  },
  "meta": { "request_id": "req_…", "timestamp": "2026-06-18T00:00:00.000Z" }
}

raw is the exact plain-text body the callback would return for the same input. When no menu is configured the simulator returns an END screen rather than an error.

Aggregator callback

Configure this URL in your aggregator dashboard (for example Africa’s Talking). It is a public webhook: the {tenantId} path segment scopes the call to the tenant that owns the menu, so no API key is sent. The aggregator posts it on every step of a session. It accepts both JSON and application/x-www-form-urlencoded bodies with the fields below, and responds with a text/plain body beginning CON (continue) or END (terminate).

Field	Type	Notes
`sessionId`	string	Aggregator session id (logged for telemetry).
`phoneNumber`	string	Subscriber MSISDN.
`serviceCode`	string	Dial code the subscriber used.
`text`	string	Accumulated input string, `*`-joined.

Callback round trip

The callback fires once when the subscriber dials the service code and again after each keypress. The aggregator sends the full text chain each time. For the menu above, the initial request has an empty text value and Orbit returns CON Welcome to Acme; after the subscriber presses 1, the aggregator sends text=1 and Orbit returns the terminal balance screen. Use the following handler shape when you receive the aggregator request. Each example reads the form-encoded fields and returns the plain-text response the aggregator expects.

# The aggregator sends this after the subscriber presses 1.
curl -X POST "https://api.orbit.devotel.io/api/v1/ussd/callback/tenant_abc123" \
  -H "Content-Type: application/x-www-form-urlencoded" \
  --data-urlencode "sessionId=ATUid_123" \
  --data-urlencode "phoneNumber=+254700000000" \
  --data-urlencode "serviceCode=*384*1#" \
  --data-urlencode "text=1"

# Orbit's response body for this step:
# CON Your balance is 250.00

import express from "express";

const app = express();
app.use(express.urlencoded({ extended: false }));

app.post("/ussd/callback", (req, res) => {
  const { sessionId, phoneNumber, serviceCode, text } = req.body as {
    sessionId: string;
    phoneNumber: string;
    serviceCode: string;
    text: string;
  };
  console.log({ sessionId, phoneNumber, serviceCode });
  const reply = text === "1" ? "CON Your balance is 250.00" : "CON Welcome to Acme";
  res.type("text/plain").send(reply);
});

from flask import Flask, request, Response

app = Flask(__name__)

@app.post("/ussd/callback")
def ussd_callback() -> Response:
    session_id = request.form["sessionId"]
    phone_number = request.form["phoneNumber"]
    service_code = request.form["serviceCode"]
    text = request.form.get("text", "")
    print(session_id, phone_number, service_code)
    reply = "CON Your balance is 250.00" if text == "1" else "CON Welcome to Acme"
    return Response(reply, content_type="text/plain")

package main

import (
  "fmt"
  "net/http"
)

func ussdCallback(w http.ResponseWriter, r *http.Request) {
  if err := r.ParseForm(); err != nil {
    http.Error(w, "invalid form", http.StatusBadRequest)
    return
  }
  sessionID := r.FormValue("sessionId")
  phoneNumber := r.FormValue("phoneNumber")
  serviceCode := r.FormValue("serviceCode")
  text := r.FormValue("text")
  fmt.Println(sessionID, phoneNumber, serviceCode)
  reply := "CON Welcome to Acme"
  if text == "1" {
    reply = "CON Your balance is 250.00"
  }
  w.Header().Set("Content-Type", "text/plain")
  _, _ = w.Write([]byte(reply))
}

require 'sinatra'

post '/ussd/callback' do
  session_id = params.fetch('sessionId')
  phone_number = params.fetch('phoneNumber')
  service_code = params.fetch('serviceCode')
  text = params.fetch('text', '')
  puts [session_id, phone_number, service_code]
  reply = text == '1' ? 'CON Your balance is 250.00' : 'CON Welcome to Acme'
  content_type 'text/plain'
  reply
end

<?php
$sessionId = $_POST['sessionId'] ?? '';
$phoneNumber = $_POST['phoneNumber'] ?? '';
$serviceCode = $_POST['serviceCode'] ?? '';
$text = $_POST['text'] ?? '';
error_log("{$sessionId} {$phoneNumber} {$serviceCode}");
$reply = $text === '1' ? 'CON Your balance is 250.00' : 'CON Welcome to Acme';
header('Content-Type: text/plain');
echo $reply;

The response body for the continuing balance step is:

CON Your balance is 250.00

When the subscriber reaches the leaf node, return END instead of CON :

END Your balance is 250.00

That terminal response closes the session after the subscriber presses 1; the preceding CON Welcome to Acme response keeps the menu open for that keypress. USSD has no “back” affordance, so an input that doesn’t match any option — or that arrives after a terminal screen — ends the session cleanly. A callback for a tenant with no configured menu ends the session with END Service is not available. rather than leaving the subscriber hanging.

Network-initiated (push) sessions

The endpoints above all answer a session the subscriber opened by dialling a short code. Push works in the opposite direction: your application asks your aggregator to open a USSD session on a subscriber’s handset — for balance prompts, mobile-money confirmations, and feature-phone OTP flows. Push has no company-wide provider. You register your own aggregator push endpoint per tenant, exactly like the inbound callback URL you set in your aggregator dashboard, and Orbit POSTs each push to it. The push URL must be an https:// URL and is re-validated and DNS-pinned against the SSRF guard on every send.

Configure the push provider

Set the aggregator endpoint your push sessions go out through with PUT /api/v1/ussd/push/config.

Field	Type	Notes
`pushUrl`	string	Required. Aggregator push endpoint. Must be an `https://` URL (≤ 2048 chars).
`serviceCode`	string	Optional default service / short code the push opens against (e.g. `3841#`).
`senderId`	string	Optional sender / channel id some aggregators require on push.
`authHeaderName`	string	Optional header name the provider authenticates with (e.g. `Authorization`, `apiKey`).
`authHeaderValue`	string	Optional credential for `authHeaderName`. Write-only — never returned on read.

curl -X PUT https://api.orbit.devotel.io/api/v1/ussd/push/config \
  -H "X-API-Key: dv_live_sk_your_key_here" \
  -H "Content-Type: application/json" \
  -d '{
    "pushUrl": "https://ussd.aggregator.example/push",
    "serviceCode": "*384*1#",
    "senderId": "ACME",
    "authHeaderName": "Authorization",
    "authHeaderValue": "Bearer agg_secret_token"
  }'

GET /api/v1/ussd/push/config returns the stored config under data.config, or data.config: null when none is set. The credential is never echoed back: instead of authHeaderValue, the read response carries authConfigured — a boolean reporting whether a credential is stored.

{
  "data": {
    "config": {
      "pushUrl": "https://ussd.aggregator.example/push",
      "serviceCode": "*384*1#",
      "senderId": "ACME",
      "authHeaderName": "Authorization",
      "authConfigured": true
    }
  },
  "meta": { "request_id": "req_…", "timestamp": "2026-06-18T00:00:00.000Z" }
}

Open a push session

POST /api/v1/ussd/push opens the session on the subscriber’s handset via the configured aggregator.

Field	Type	Notes
`phoneNumber`	string	Required. Destination handset in E.164 (e.g. `+234801234567`). A leading `+` is added if omitted.
`message`	string	Required. First screen text (1–182 chars).
`action`	string	`CON` keeps the session open for a reply; `END` shows a one-shot notice. Defaults to `CON`.
`serviceCode`	string	Optional override of the configured default service code for this push.
`clientRequestId`	string	Optional idempotency / correlation key, echoed to the aggregator.

Push session initiation

Configure the aggregator endpoint once, then call POST /api/v1/ussd/push to open a session on the subscriber’s handset. The first screen below matches the simulator menu above: it greets the subscriber with Welcome to Acme, and the callback continues with the balance screen when the subscriber replies 1.

curl -X PUT https://api.orbit.devotel.io/api/v1/ussd/push/config \
  -H "X-API-Key: dv_live_sk_your_key_here" \
  -H "Content-Type: application/json" \
  -d '{"pushUrl":"https://ussd.aggregator.example/push","serviceCode":"*384*1#"}'

curl -X POST https://api.orbit.devotel.io/api/v1/ussd/push \
  -H "X-API-Key: dv_live_sk_your_key_here" \
  -H "Content-Type: application/json" \
  -d '{"phoneNumber":"+234801234567","message":"Welcome to Acme. Reply 1 to check your balance.","action":"CON","clientRequestId":"acme-balance-001"}'

import { Orbit } from "@devotel-orbit/node";

const orbit = new Orbit({ apiKey: process.env.ORBIT_API_KEY! });
await orbit.request("PUT", "/ussd/push/config", {
  pushUrl: "https://ussd.aggregator.example/push",
  serviceCode: "*384*1#",
});
const result = await orbit.request("POST", "/ussd/push", {
  phoneNumber: "+234801234567",
  message: "Welcome to Acme. Reply 1 to check your balance.",
  action: "CON",
  clientRequestId: "acme-balance-001",
});
console.log(result.data);

from orbit_sdk import OrbitClient

client = OrbitClient.from_env()
client.request("PUT", "/ussd/push/config", {
    "pushUrl": "https://ussd.aggregator.example/push",
    "serviceCode": "*384*1#",
})
result = client.request("POST", "/ussd/push", {
    "phoneNumber": "+234801234567",
    "message": "Welcome to Acme. Reply 1 to check your balance.",
    "action": "CON",
    "clientRequestId": "acme-balance-001",
})
print(result["data"])

package main

import (
  "bytes"
  "encoding/json"
  "fmt"
  "net/http"
  "os"
)

func call(method, path string, payload map[string]string) {
  body, _ := json.Marshal(payload)
  req, _ := http.NewRequest(method, "https://api.orbit.devotel.io/api/v1"+path, bytes.NewReader(body))
  req.Header.Set("X-API-Key", os.Getenv("ORBIT_API_KEY"))
  req.Header.Set("Content-Type", "application/json")
  res, _ := http.DefaultClient.Do(req)
  defer res.Body.Close()
  fmt.Println(res.Status)
}

func main() {
  call("PUT", "/ussd/push/config", map[string]string{
    "pushUrl": "https://ussd.aggregator.example/push", "serviceCode": "*384*1#",
  })
  call("POST", "/ussd/push", map[string]string{
    "phoneNumber": "+234801234567", "message": "Welcome to Acme. Reply 1 to check your balance.",
    "action": "CON", "clientRequestId": "acme-balance-001",
  })
}

require 'json'
require 'net/http'

BASE = 'https://api.orbit.devotel.io/api/v1'
KEY = ENV['ORBIT_API_KEY']

def call(method, path, body)
  uri = URI("#{BASE}#{path}")
  request = method.new(uri)
  request['X-API-Key'] = KEY
  request['Content-Type'] = 'application/json'
  request.body = JSON.dump(body)
  Net::HTTP.start(uri.host, uri.port, use_ssl: true) { |http| http.request(request) }
end

call(Net::HTTP::Put, '/ussd/push/config', {
  pushUrl: 'https://ussd.aggregator.example/push', serviceCode: '*384*1#'
})
result = call(Net::HTTP::Post, '/ussd/push', {
  phoneNumber: '+234801234567', message: 'Welcome to Acme. Reply 1 to check your balance.',
  action: 'CON', clientRequestId: 'acme-balance-001'
})
puts result.body

<?php
$key = getenv('ORBIT_API_KEY');

function call_api(string $method, string $path, string $key, array $body): string {
  $ch = curl_init("https://api.orbit.devotel.io/api/v1{$path}");
  curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
  curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
  curl_setopt($ch, CURLOPT_HTTPHEADER, ['X-API-Key: ' . $key, 'Content-Type: application/json']);
  curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($body));
  return curl_exec($ch);
}

call_api('PUT', '/ussd/push/config', $key, [
  'pushUrl' => 'https://ussd.aggregator.example/push', 'serviceCode' => '*384*1#'
]);
$result = call_api('POST', '/ussd/push', $key, [
  'phoneNumber' => '+234801234567', 'message' => 'Welcome to Acme. Reply 1 to check your balance.',
  'action' => 'CON', 'clientRequestId' => 'acme-balance-001'
]);
echo $result;

{
  "data": {
    "status": "accepted",
    "providerStatus": 200,
    "phoneNumber": "+234801234567"
  },
  "meta": { "request_id": "req_…", "timestamp": "2026-06-18T00:00:00.000Z" }
}

providerStatus is the HTTP status your aggregator returned (a 2xx). accepted means the aggregator took the session; the subscriber’s reply, if any, then arrives on your aggregator callback like any other step.

Error codes

Status	When
`409`	No push provider is configured yet — set one via `PUT /api/v1/ussd/push/config` first.
`422`	The request body is invalid, or the configured `pushUrl` was rejected by the SSRF guard.
`502`	The aggregator could not be reached, or returned a non-2xx response.

USSD sessions never originate outbound voice or SMS. The reply is returned synchronously to the aggregator inside the open session, so no termination path is involved.

API Reference

All Endpoints

USSD API: menu trees, sessions, and aggregator callbacks

USSD API

Using the SDKs

How a session works

Endpoints

The menu definition

Create or replace a menu

Simulate a session step

Aggregator callback

Callback round trip

Network-initiated (push) sessions

Configure the push provider

Open a push session

Push session initiation

Error codes

See also

​USSD API

​Using the SDKs

​How a session works

​Endpoints

​The menu definition

​Create or replace a menu

​Simulate a session step

​Aggregator callback

​Callback round trip

​Network-initiated (push) sessions

​Configure the push provider

​Open a push session

​Push session initiation

​Error codes

​See also

USSD API

Using the SDKs

How a session works

Endpoints

The menu definition

Create or replace a menu

Simulate a session step

Aggregator callback

Callback round trip

Network-initiated (push) sessions

Configure the push provider

Open a push session

Push session initiation

Error codes

See also