# List taxonomy URL: https://docs.hanzo.ai/docs/openapi/taxonomy/get-taxonomy > 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. `GET /v1/taxonomy` > [Taxonomy →](https://docs.hanzo.ai/docs/openapi/taxonomy) · [All API references →](https://docs.hanzo.ai/docs/openapi) · [Get started →](https://docs.hanzo.ai/docs/guides) | | | | ------------- | -------------------------------------- | | **Address** | `https://api.hanzo.ai/v1/taxonomy` | | **Method** | `GET` | | **Operation** | `get_taxonomy` | | **Auth** | `Authorization: Bearer $HANZO_API_KEY` | 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.Taxonomy | ok | | `default` | problem-details | refused | `200` body — 20 fields. | Field | In | Type | Always | Description | | --------------------------------- | ---- | -------------------- | ------ | ---------------------------------------------------------------------------------------------------------------------------------- | | `categories` | body | taxonomy.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. "observe". | | `categories[].label` | body | string | — | Label is the display name, e.g. "Observe". | | `categories[].order` | body | integer (int64) | — | 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 | taxonomy.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. "Database". | | `categories[].taxa[].id` | body | string | — | ID is the stable slug this taxon is addressed by, e.g. "vector". | | `categories[].taxa[].name` | body | string | — | Name is the display name, e.g. "Vector". | | `categories[].taxa[].order` | body | integer (int64) | — | 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. "/vector". | | `categories[].taxa[].tags` | body | string\[] | — | Tags are free-form labels for search and grouping across categories. | Failure carries the platform error shape — see [Errors](https://docs.hanzo.ai/docs/errors). ## Examples **CLI** ```bash hanzo taxonomy get ``` **SDK** **.ts** ```ts import { Configuration, TaxonomyApi } from 'hanzoai'; const api = new TaxonomyApi(new Configuration({ accessToken: process.env.HANZO_API_KEY })); const { data } = await api.getTaxonomy(); ``` **.py** ```python 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() ``` **.go** ```go cfg := hanzoai.NewConfiguration() cfg.AddDefaultHeader("Authorization", "Bearer "+os.Getenv("HANZO_API_KEY")) client := hanzoai.NewAPIClient(cfg) resp, _, err := client.TaxonomyAPI.GetTaxonomy(context.Background()).Execute() if err != nil { return err } ``` **.rs** ```rust use hanzo_client::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?; ``` **.java** ```java import ai.hanzo.cloud.ApiClient; import ai.hanzo.cloud.api.TaxonomyApi; ApiClient client = new ApiClient(); client.setBearerToken(System.getenv("HANZO_API_KEY")); var result = new TaxonomyApi(client).getTaxonomy(); ``` **HTTP** ```bash curl https://api.hanzo.ai/v1/taxonomy \ -H "Authorization: Bearer $HANZO_API_KEY" ``` **MCP** MCP reaches **taxonomy** through the `taxonomy` tool, which names its 5 operations with its own verbs — this one among them, under a name only MCP declares. `describe` explains any of them: ```bash 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_taxonomies" } } }' ``` --- [Taxonomy API](https://docs.hanzo.ai/docs/openapi/taxonomy) · [All Hanzo APIs](https://docs.hanzo.ai/docs/openapi) · [Interactive reference](https://docs.hanzo.ai/docs/openapi/reference)