# Get coverage URL: https://docs.hanzo.ai/docs/openapi/trust/get-trust-coverage-by-framework > Reads one framework clause by clause: every clause the standard publishes, what covers it, and which controls stand behind it — so a coverage number can be checked line by line rather than taken on trust. `GET /v1/trust/coverage/{framework}` > [Trust →](https://docs.hanzo.ai/docs/openapi/trust) · [All API references →](https://docs.hanzo.ai/docs/openapi) · [Get started →](https://docs.hanzo.ai/docs/guides) | | | | ------------- | ---------------------------------------------------- | | **Address** | `https://api.hanzo.ai/v1/trust/coverage/{framework}` | | **Method** | `GET` | | **Operation** | `get_trust_coverage_by_framework` | | **Auth** | `Authorization: Bearer $HANZO_API_KEY` | Reads one framework clause by clause: every clause the standard publishes, what covers it, and which controls stand behind it — so a coverage number can be checked line by line rather than taken on trust. ## Request 1 field. | Field | In | Type | Required | Description | | ----------- | ---- | ------ | -------- | ---------------------------------------------------------------- | | `framework` | path | string | yes | Framework is the framework id — "soc2", "iso27001", "nist80053". | ## Response | Status | Body | Meaning | | --------- | -------------------- | ------- | | `200` | trust.clauseCoverage | ok | | `default` | problem-details | refused | `200` body — 20 fields. | Field | In | Type | Always | Description | | -------------------- | ---- | ------------------ | ------ | --------------------------------------------------------------------------------------------------------- | | `automated` | body | integer (int64) | — | Automated is how many clauses have an automated control behind them that something can fail on behalf of. | | `clauses` | body | trust.clauseRow\[] | — | Clauses is every clause the standard publishes, with what stands behind it. | | `clauses[].controls` | body | string\[] | — | Controls are the ids behind it, strongest first. | | `clauses[].group` | body | string | — | Group is the clause's section within the standard, when it has one. | | `clauses[].id` | body | string | — | ID is the clause id as the standard publishes it — "CC6.1", "A.5.15", "AC". | | `clauses[].level` | body | string | — | Level is what the strongest control pointed at this clause is worth: "automated", "partial" or "none". | | `clauses[].title` | body | string | — | Title is the standard's own words for that clause. | | `edition` | body | string | — | Edition is which edition this clause list is taken from. | | `framework` | body | string | — | Framework is the framework id — "soc2", "iso27001", "nist80053". | | `generated` | body | integer (int64) | — | Generated is when this was computed, unix milliseconds. | | `name` | body | string | — | Name is the published standard's name. | | `none` | body | integer (int64) | — | None is how many have nothing behind them. | | `note` | body | string | — | Note is what this clause list is scoped to, when a count alone would misrepresent it. | | `partial` | body | integer (int64) | — | Partial is how many are answered in part. | | `publisher` | body | string | — | Publisher is who publishes it — AICPA, ISO/IEC, NIST. | | `statement` | body | string | — | Statement is the counts as one sentence, carrying the unit. | | `total` | body | integer (int64) | — | Total is the framework's WHOLE published clause list — the denominator. | | `unit` | body | string | — | Unit is what ONE clause is — "criterion", "control", "family". | | `units` | body | string | — | Units is the plural of Unit, for rendering a sentence. | | `version` | body | string | — | Version is the embedded inventory's version. | Failure carries the platform error shape — see [Errors](https://docs.hanzo.ai/docs/errors). ## Examples **CLI** ```bash hanzo trust coverage get ``` **SDK** **.ts** ```ts import { Configuration, TrustApi } from 'hanzoai'; const api = new TrustApi(new Configuration({ accessToken: process.env.HANZO_API_KEY })); const { data } = await api.getTrustCoverageByFramework({ framework: 'framework' }); ``` **.py** ```python from hanzoai.cloud import ApiClient, Configuration from hanzoai.cloud.api import TrustApi client = ApiClient(Configuration(access_token=os.environ["HANZO_API_KEY"])) result = TrustApi(client).get_trust_coverage_by_framework(framework='framework') ``` **.go** ```go cfg := hanzoai.NewConfiguration() cfg.AddDefaultHeader("Authorization", "Bearer "+os.Getenv("HANZO_API_KEY")) client := hanzoai.NewAPIClient(cfg) resp, _, err := client.TrustAPI.GetTrustCoverageByFramework(context.Background()).Execute() if err != nil { return err } ``` **.rs** ```rust use hanzo_client::apis::{configuration::Configuration, trust_api}; let mut cfg = Configuration::new(); cfg.bearer_access_token = std::env::var("HANZO_API_KEY").ok(); let result = trust_api::get_trust_coverage_by_framework(&cfg, Default::default()).await?; ``` **.java** ```java import ai.hanzo.cloud.ApiClient; import ai.hanzo.cloud.api.TrustApi; ApiClient client = new ApiClient(); client.setBearerToken(System.getenv("HANZO_API_KEY")); var result = new TrustApi(client).getTrustCoverageByFramework(); ``` **HTTP** ```bash curl https://api.hanzo.ai/v1/trust/coverage/ \ -H "Authorization: Bearer $HANZO_API_KEY" ``` **MCP** Tool `trust`, op `get_trust_coverage_by_framework` — 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": "trust", "arguments": { "op": "get_trust_coverage_by_framework", "input": { "framework": "" } } } }' ``` --- [Trust API](https://docs.hanzo.ai/docs/openapi/trust) · [All Hanzo APIs](https://docs.hanzo.ai/docs/openapi) · [Interactive reference](https://docs.hanzo.ai/docs/openapi/reference)