# List tariff URL: https://docs.hanzo.ai/docs/openapi/pricing/get-pricing-tariff > Returns the platform's rate card: what a bill is made of, what each part costs, and the completion windows a request may ask for. `GET /v1/pricing/tariff` > [Pricing →](https://docs.hanzo.ai/docs/openapi/pricing) · [All API references →](https://docs.hanzo.ai/docs/openapi) · [Get started →](https://docs.hanzo.ai/docs/guides) | | | | ------------- | ---------------------------------------- | | **Address** | `https://api.hanzo.ai/v1/pricing/tariff` | | **Method** | `GET` | | **Operation** | `get_pricing_tariff` | | **Auth** | `Authorization: Bearer $HANZO_API_KEY` | Returns the platform's rate card: what a bill is made of, what each part costs, and the completion windows a request may ask for. FOUR COMPONENTS, and every charge is one of them — model inference, computer, web tools and media generation. Two are quoted before they run, so an agent is refused before it breaches its budget; two are booked from what they used, because neither a provider's charge nor a render's cost is knowable in advance. EVERY AMOUNT IS INTEGER MICRO-USD (1 USD = 1,000,000), stated once in `unit`, and each rate says what one unit of it is in `per`. The compute rates are per HOUR because that is the unit a span is priced in — rate × seconds / 3600 — and because a GiB-second is four and a half micro-USD, which no integer holds. The rates are the ones the ledger books: each is resolved through the same authority the metering path reads, falling back to the same compiled floor. A rate of zero is a price and not an absence — a paused computer, a computer's creation, the interfaces and a seat all cost nothing by design. ## Request `GET /v1/pricing/tariff` takes no parameters and no body — the credential is the whole request. ## Response | Status | Body | Meaning | | --------- | --------------- | ------- | | `200` | pricing.Card | ok | | `default` | problem-details | refused | `200` body — 19 fields. | Field | In | Type | Always | Description | | ------------------------ | ---- | -------------------- | ------ | -------------------------------------------------------------------------- | | `components` | body | pricing.Component\[] | — | Components are the four things a bill is made of. | | `components[].basis` | body | string | — | Basis is what it is metered by, in the fewest words that are true. | | `components[].name` | body | string | — | Name is the component's name on the spend breakdown. | | `components[].note` | body | string | — | Note is what the component means, in one sentence. | | `components[].quoted` | body | boolean | — | Quoted says whether a call is priced BEFORE it runs. | | `components[].tiers` | body | string\[] | — | Tiers are the disjoint tiers this component meters in, where it has them. | | `components[].title` | body | string | — | Title is how it reads on a price list. | | `rates` | body | pricing.Rate\[] | — | Rates are the priced lines, each in micro-USD per its own unit. | | `rates[].component` | body | string | — | Component is which of the four this line bills under. | | `rates[].name` | body | string | — | Name addresses the rate. | | `rates[].note` | body | string | — | Note is what the line covers. | | `rates[].per` | body | string | — | Per names one unit, so a reader never has to guess what the number is per. | | `rates[].rate_micro_usd` | body | integer (int64) | — | Micros is the price of ONE unit, in micro-USD. | | `rates[].title` | body | string | — | Title is how the line reads on a price list. | | `unit` | body | string | — | Unit is the unit every amount on this card is stated in. | | `windows` | body | pricing.Speed\[] | — | Speeds are the completion speeds, dearest first. | | `windows[].name` | body | string | — | Name is what a request asks for. | | `windows[].note` | body | string | — | Note is what asking for this window buys. | | `windows[].rank` | body | integer (int64) | — | Rank orders the windows by price, 1 being the dearest. | Failure carries the platform error shape — see [Errors](https://docs.hanzo.ai/docs/errors). ## Examples **CLI** ```bash hanzo pricing tariff ``` **SDK** **.ts** ```ts import { Configuration, PricingApi } from 'hanzoai'; const api = new PricingApi(new Configuration({ accessToken: process.env.HANZO_API_KEY })); const { data } = await api.getPricingTariff(); ``` **.py** ```python from hanzoai.cloud import ApiClient, Configuration from hanzoai.cloud.api import PricingApi client = ApiClient(Configuration(access_token=os.environ["HANZO_API_KEY"])) result = PricingApi(client).get_pricing_tariff() ``` **.go** ```go cfg := hanzoai.NewConfiguration() cfg.AddDefaultHeader("Authorization", "Bearer "+os.Getenv("HANZO_API_KEY")) client := hanzoai.NewAPIClient(cfg) resp, _, err := client.PricingAPI.GetPricingTariff(context.Background()).Execute() if err != nil { return err } ``` **.rs** ```rust use hanzo_client::apis::{configuration::Configuration, pricing_api}; let mut cfg = Configuration::new(); cfg.bearer_access_token = std::env::var("HANZO_API_KEY").ok(); let result = pricing_api::get_pricing_tariff(&cfg, Default::default()).await?; ``` **.java** ```java import ai.hanzo.cloud.ApiClient; import ai.hanzo.cloud.api.PricingApi; ApiClient client = new ApiClient(); client.setBearerToken(System.getenv("HANZO_API_KEY")); var result = new PricingApi(client).getPricingTariff(); ``` **HTTP** ```bash curl https://api.hanzo.ai/v1/pricing/tariff \ -H "Authorization: Bearer $HANZO_API_KEY" ``` **MCP** Tool `pricing`, op `get_pricing_tariff` — POST the JSON-RPC envelope to `https://api.hanzo.ai/v1/mcp`. ```bash 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": "pricing", "arguments": { "op": "get_pricing_tariff", "input": {} } } }' ``` --- [Pricing API](https://docs.hanzo.ai/docs/openapi/pricing) · [All Hanzo APIs](https://docs.hanzo.ai/docs/openapi) · [Interactive reference](https://docs.hanzo.ai/docs/openapi/reference)