Read returns the product catalogue as this caller sees it: the PLATFORM…

Read returns the product catalogue as this caller sees it: the PLATFORM catalogue — Hanzo's own products, the part that is true for everyone — plus the…

GET /v1/taxonomy

Taxonomy → · All API references → · Six flows, four surfaces →


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

Read returns the product catalogue as this caller sees it: the PLATFORM catalogue — Hanzo's own products, the part that is true for everyone — plus the caller's own org's rows, every category in display order and each carrying the products filed under it in theirs. Another customer's rows are never in it. It is readable signed out, and a signed-out visitor gets the platform catalogue alone, which is what the marketing landing renders from.

Where the caller's org and the platform hold the same id, the caller's own row is the one served. That rule exists because ids are unique per ORG and not globally — two customers may each have a "crm", and refusing the second would tell one of them the other exists — so a collision with the platform is possible by construction and something has to win deterministically. Yours does: your own catalogue is the one you edited.

?brand= narrows it the way a brand's own console does: only the categories that brand admits, and within them only the taxa scoped to it. An unpublished row is served only to whoever may edit it — a SuperAdmin for the platform's, an org admin for their own — so a product can be staged before anyone sees it without becoming invisible to the person staging it.

Request

1 field.

Field	In	Type	Required	Description
`brand`	query	string	—	Brand returns only what that brand's console shows — the categories it admits, and within them the taxa scoped to it.

Response

Status	Body	Meaning
`200`	Taxonomy	ok

200 body — 20 fields.

Field	In	Type	Always	Description
`categories`	body	Category[]	—	Categories are the groupings, in display order, each with its own taxa.
`categories[].brands`	body	string[]	—	Brands are the brands whose console shows this category.
`categories[].id`	body	string	—	ID is the stable slug this category is addressed by, e.g.
`categories[].label`	body	string	—	Label is the display name, e.g.
`categories[].order`	body	integer	—	Order is where the category sits among its siblings, ascending.
`categories[].owner`	body	string	—	Owner is the org this category belongs to: the platform's own org for a category every tenant sees, or your org for one you added.
`categories[].summary`	body	string	—	Summary is the one line describing what the category groups, shown as the header copy on its landing page.
`categories[].taxa`	body	Taxon[]	—	Taxa are the products filed under this category, in display order.
`categories[].taxa[].brands`	body	string[]	—	Brands are the brands whose console shows this taxon.
`categories[].taxa[].category`	body	string	—	Category is the id of the category this taxon is filed under.
`categories[].taxa[].description`	body	string	—	Description is the one line shown beneath the name in the catalogue and nav.
`categories[].taxa[].href`	body	string	—	Href is the absolute URL an external product launches, for the taxa that genuinely live at their own domain.
`categories[].taxa[].icon`	body	string	—	Icon names the icon the surface renders, e.g.
`categories[].taxa[].id`	body	string	—	ID is the stable slug this taxon is addressed by, e.g.
`categories[].taxa[].name`	body	string	—	Name is the display name, e.g.
`categories[].taxa[].order`	body	integer	—	Order is where the taxon sits within its category, ascending.
`categories[].taxa[].owner`	body	string	—	Owner is the org this product belongs to: the platform's own org for one every tenant sees, or your org for one you added.
`categories[].taxa[].published`	body	boolean	—	Published is whether the taxon is shown.
`categories[].taxa[].route`	body	string	—	Route is the in-console path this taxon opens, e.g.
`categories[].taxa[].tags`	body	string[]	—	Tags are free-form labels for search and grouping across categories.

Failure carries the platform error shape — see Errors.

Examples

hanzo taxonomy get

import { Configuration, TaxonomyApi } from 'hanzoai';

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

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

client = ApiClient(Configuration(access_token=os.environ["HANZO_API_KEY"]))
result = TaxonomyApi(client).get_taxonomy()

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

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

use hanzo_cloud::apis::{configuration::Configuration, taxonomy_api};

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

let result = taxonomy_api::get_taxonomy(&cfg, Default::default()).await?;

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

ApiClient client = new ApiClient();
client.setRequestInterceptor(b -> b.header("Authorization", "Bearer " + System.getenv("HANZO_API_KEY")));

var result = new TaxonomyApi(client).getTaxonomy();

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

Tool taxonomy, op get_taxonomy — POST the JSON-RPC envelope to https://api.hanzo.ai/v1/mcp.

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

Taxonomy API · All Hanzo APIs · Interactive reference

Read returns the product catalogue as this caller sees it: the PLATFORM…

Request

Response

Examples

On this page