List transport

Reports every chat transport this org can send through, and whether it can send through it right now.

GET /v1/transport

Transport → · All API references → · Get started →

Address	`https://api.hanzo.ai/v1/transport`
Method	`GET`
Operation	`get_transport`
Auth	`Authorization: Bearer $HANZO_API_KEY`

Reports every chat transport this org can send through, and whether it can send through it right now.

A transport appears here whether or not it is connected — an empty list would leave a caller unable to tell "this org has no Slack" from "Slack is down", which are different problems with different fixes. Each entry carries the connection behind it, so the answer to "why can I not post?" is in the same response as the transport that cannot post.

Request

GET /v1/transport takes no parameters and no body — the credential is the whole request.

Response

Status	Body	Meaning
`200`	transport.chatTransports	ok
`default`	problem-details	refused

200 body — 15 fields.

Field	In	Type	Always	Description
`transports`	body	transport.transportView[]	—	Transports is every chat transport this deployment supports, in a fixed order, each carrying whether the org has connected it, the account behind the connection, what the transport can do, the org's DM/group access policies for it, and how many pairing requests are waiting.
`transports[].account`	body	string	—	Account is the id-shaped fact about that connection: the lowercased external id integrations custodies for it — a Discord guild id, a Slack team (workspace) id, a Teams AAD tenant id, or the Telegram chat the org bound.
`transports[].accountLabel`	body	string	—	AccountLabel is the human label of that same account — the Discord guild name, the Slack team name, the Teams tenant name (falling back to the tenant id), the Telegram chat title.
`transports[].capabilities`	body	transport.capabilities	—
`transports[].capabilities.actions`	body	boolean	—	Actions is whether the transport renders an INTERACTIVE control natively, and it is the flag to read before composing one.
`transports[].capabilities.dm`	body	boolean	—	DM is whether the transport carries a DIRECT message at all.
`transports[].capabilities.edit`	body	boolean	—	Edit is whether a sent message can be rewritten in place.
`transports[].capabilities.group`	body	boolean	—	Group is whether the transport carries multi-person channels — a Discord guild transport, a Slack channel, a Teams channel or group chat, a Telegram group or supergroup, a WhatsApp group.
`transports[].capabilities.media`	body	boolean	—	Media is whether the transport renders an ATTACHMENT natively.
`transports[].capabilities.thread`	body	boolean	—	Thread is whether a reply can be threaded UNDER a specific message.
`transports[].connected`	body	boolean	—	Connected is whether integrations holds a connection for (this org, this transport) — whether someone finished its connect flow.
`transports[].dmPolicy`	body	string	—	DMPolicy is how this org admits direct messages here: "pairing", "allowlist" or "open", defaulting to "pairing" when the org has never set one.
`transports[].groupPolicy`	body	string	—	GroupPolicy is how this org admits group and thread channels here: "open", "allowlist" or "disabled", defaulting to "open".
`transports[].id`	body	string	—	ID is the fixed transport identifier — discord, slack, teams, telegram or whatsapp — and the value every route on this surface names a transport by, including the `:transport` segment of the send path.
`transports[].pendingPairing`	body	integer (int64)	—	PendingPairing counts the org's UNEXPIRED pairing requests on this transport: exactly the rows GET /v1/transport/pairing returns for it, one per person waiting on an admin.

Failure carries the platform error shape — see Errors.

Examples

CLI

SDK

HTTP

MCP

hanzo transport list

.ts

.py

.go

.rs

.java

import { Configuration, TransportApi } from 'hanzoai';

const api = new TransportApi(new Configuration({ accessToken: process.env.HANZO_API_KEY }));
const { data } = await api.getTransport();

from hanzoai.cloud import ApiClient, Configuration
from hanzoai.cloud.api import TransportApi

client = ApiClient(Configuration(access_token=os.environ["HANZO_API_KEY"]))
result = TransportApi(client).get_transport()

cfg := hanzoai.NewConfiguration()
cfg.AddDefaultHeader("Authorization", "Bearer "+os.Getenv("HANZO_API_KEY"))
client := hanzoai.NewAPIClient(cfg)

resp, _, err := client.TransportAPI.GetTransport(context.Background()).Execute()
if err != nil {
	return err
}

use hanzo_client::apis::{configuration::Configuration, transport_api};

let mut cfg = Configuration::new();
cfg.bearer_access_token = std::env::var("HANZO_API_KEY").ok();

let result = transport_api::get_transport(&cfg, Default::default()).await?;

import ai.hanzo.cloud.ApiClient;
import ai.hanzo.cloud.api.TransportApi;

ApiClient client = new ApiClient();
client.setBearerToken(System.getenv("HANZO_API_KEY"));

var result = new TransportApi(client).getTransport();

The method above is the one at the current release of the document. [email protected] (npm) and [email protected] (PyPI) were generated from an earlier release, where this operation carried a different id, so it spells the method differently — regenerating the clients is what makes the two agree. SDKs →

curl https://api.hanzo.ai/v1/transport \
  -H "Authorization: Bearer $HANZO_API_KEY"

MCP reaches transport through the transport tool, which names its 8 operations with its own verbs — this one among them, under a name only MCP declares. describe explains any of them:

curl -X POST https://api.hanzo.ai/v1/mcp \
  -H "Content-Type: application/json" \
  -d '{
       "jsonrpc": "2.0",
       "id": 1,
       "method": "tools/call",
       "params": {
         "name": "describe",
         "arguments": {
           "op": "list_transports"
         }
       }
     }'

Transport API · All Hanzo APIs · Interactive reference

Was this page useful?

Broken link or missing step? Drop it in #docs on Discord or open a PR.

PreviousList pairing NextSend transport