List triggers

What calls the caller org's functions — one row per function.

GET /v1/function/triggers

Function → · All API references → · Get started →

Address	`https://api.hanzo.ai/v1/function/triggers`
Method	`GET`
Operation	`get_function_triggers`
Auth	`Authorization: Bearer $HANZO_API_KEY`

What calls the caller org's functions — one row per function.

Every function has exactly one trigger today, its HTTP invoke endpoint, so this is the function list read as "how is each of these reached".

Request

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

Response

Status	Body	Meaning
`200`	function.triggerList	ok
`default`	problem-details	refused

200 body — 7 fields.

Field	In	Type	Always	Description
`triggers`	body	function.triggerView[]	—	Triggers is one row per function, describing how it is reached.
`triggers[].enabled`	body	boolean	—	whether it currently fires
`triggers[].functionName`	body	string	—	the function it calls
`triggers[].id`	body	string	—	the trigger's handle
`triggers[].name`	body	string	—	a human label for it
`triggers[].target`	body	string	—	the path it calls
`triggers[].type`	body	string	—	what kind of trigger it is; HTTP is the only one today

Failure carries the platform error shape — see Errors.

Examples

CLI

SDK

HTTP

MCP

hanzo function triggers

.ts

.py

.go

.rs

.java

import { Configuration, FunctionApi } from 'hanzoai';

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

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

client = ApiClient(Configuration(access_token=os.environ["HANZO_API_KEY"]))
result = FunctionApi(client).get_function_triggers()

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

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

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

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

let result = function_api::get_function_triggers(&cfg, Default::default()).await?;

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

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

var result = new FunctionApi(client).getFunctionTriggers();

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

MCP reaches function through the function tool, which names its 10 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_functions"
         }
       }
     }'

Function API · All Hanzo APIs · Interactive reference

Was this page useful?

PreviousList secrets NextList function