# List frameworks

URL: https://docs.hanzo.ai/docs/openapi/trust/get-trust-frameworks

> Lists the frameworks coverage is computed against, and how many clauses each publishes.

`GET /v1/trust/frameworks`

> [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/frameworks` |
| **Method**    | `GET`                                      |
| **Operation** | `get_trust_frameworks`                     |
| **Auth**      | `Authorization: Bearer $HANZO_API_KEY`     |

Lists the frameworks coverage is computed against, and how many clauses each
publishes. That count is the denominator of every coverage number, which is
what keeps an uncovered clause visible instead of dropping out of the
fraction.

## Request

`GET /v1/trust/frameworks` takes no parameters and no body — the credential is the whole request.

## Response

| Status    | Body                | Meaning |
| --------- | ------------------- | ------- |
| `200`     | trust.frameworkList | ok      |
| `default` | problem-details     | refused |

`200` body — 8 fields.

| Field                    | In   | Type                  | Always | Description                                                                                                            |
| ------------------------ | ---- | --------------------- | ------ | ---------------------------------------------------------------------------------------------------------------------- |
| `frameworks`             | body | trust.frameworkRow\[] | —      | Frameworks is each framework and how many clauses it publishes.                                                        |
| `frameworks[].edition`   | body | string                | —      | Edition is which edition this clause list is taken from.                                                               |
| `frameworks[].framework` | body | string                | —      | Framework is the framework id.                                                                                         |
| `frameworks[].name`      | body | string                | —      | Name is the published standard's name.                                                                                 |
| `frameworks[].publisher` | body | string                | —      | Publisher is who publishes it.                                                                                         |
| `frameworks[].total`     | body | integer (int64)       | —      | Total is how many clauses the standard publishes.                                                                      |
| `frameworks[].unit`      | body | string                | —      | Unit is what one clause is; Units is its plural.                                                                       |
| `frameworks[].units`     | body | string                | —      | Units is Unit's plural, carried so a caller renders "12 controls" without having to pluralise a word it does not know. |

Failure carries the platform error shape — see [Errors](https://docs.hanzo.ai/docs/errors).

## Examples

**CLI**

```bash
hanzo trust frameworks
```

**SDK**

**.ts**

```ts
import { Configuration, TrustApi } from 'hanzoai';

const api = new TrustApi(new Configuration({ accessToken: process.env.HANZO_API_KEY }));
const { data } = await api.getTrustFrameworks();
```

**.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_frameworks()
```

**.go**

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

resp, _, err := client.TrustAPI.GetTrustFrameworks(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_frameworks(&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).getTrustFrameworks();
```

**HTTP**

```bash
curl https://api.hanzo.ai/v1/trust/frameworks \
  -H "Authorization: Bearer $HANZO_API_KEY"
```

**MCP**

MCP reaches **trust** through the `trust` tool, which names its 17 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_trusts"
         }
       }
     }'
```

---

[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)