Run provider

Runs one action of a connector as the caller's org, with the credential the org connected, and answers what the action returned.

POST /v1/provider/{provider}/run

Provider → · All API references → · Get started →

Address	`https://api.hanzo.ai/v1/provider/{provider}/run`
Method	`POST`
Operation	`post_provider_by_provider_run`
Auth	`Authorization: Bearer $HANZO_API_KEY`

Runs one action of a connector as the caller's org, with the credential the org connected, and answers what the action returned. The credential is read from the org's KMS namespace here and never leaves this service. An action that ran and failed is ok:false with the reason; an unknown connector is 404, an action that does not run on this deployment 422, and a connector the org has not connected 424.

Request

5 fields, body application/json (required).

Field	In	Type	Required	Description
`provider`	path	string	yes	Provider is the connector, from the path.
`action`	body	string	—	Action is the action's name, as GET /v1/provider/{provider} lists it.
`input`	body	object	—	Input is the action's props, by name.
`input.*`	body	any	—
`provider`	body	string	—	Provider is the connector, from the path.

Response

Status	Body	Meaning
`200`	provider.runOut	ok
`default`	problem-details	refused

200 body — 3 fields.

Field	In	Type	Always	Description
`error`	body	string	—	Error is why the action failed, when it did.
`ok`	body	boolean	—	Ok is whether the action ran to completion.
`output`	body	any	—	Output is the action's result when it ran; its shape is the action's own.

Failure carries the platform error shape — see Errors.

Examples

CLI

SDK

HTTP

MCP

hanzo has no subcommand for this operation — the CLI serves only what cloud's live route table confirms. Use HTTP or an SDK.

.ts

.py

.go

.rs

.java

import { Configuration, ProviderApi } from 'hanzoai';

const api = new ProviderApi(new Configuration({ accessToken: process.env.HANZO_API_KEY }));
const { data } = await api.postProviderByProviderRun({ provider: 'provider', action: "<action>", input: {} });

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

client = ApiClient(Configuration(access_token=os.environ["HANZO_API_KEY"]))
result = ProviderApi(client).post_provider_by_provider_run(provider='provider', action="<action>", input={})

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

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

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

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

let result = provider_api::post_provider_by_provider_run(&cfg, Default::default()).await?;

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

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

var result = new ProviderApi(client).postProviderByProviderRun();

curl -X POST https://api.hanzo.ai/v1/provider/<provider>/run \
  -H "Authorization: Bearer $HANZO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
       "action": "<action>",
       "input": {}
     }'

MCP reaches provider through the provider tool, which names its 38 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_connections"
         }
       }
     }'

Provider API · All Hanzo APIs · Interactive reference

Was this page useful?

PreviousDisconnect provider NextVerify provider