# Create requests

URL: https://docs.hanzo.ai/docs/openapi/dataroom/post-dataroom-trust-center-by-slug-requests

> Records a request to read what an independent auditor signed, and answers with its id.

`POST /v1/dataroom/trust/center/{slug}/requests`

> [Dataroom →](https://docs.hanzo.ai/docs/openapi/dataroom) · [All API references →](https://docs.hanzo.ai/docs/openapi) · [Get started →](https://docs.hanzo.ai/docs/guides)

|               |                                                                 |
| ------------- | --------------------------------------------------------------- |
| **Address**   | `https://api.hanzo.ai/v1/dataroom/trust/center/{slug}/requests` |
| **Method**    | `POST`                                                          |
| **Operation** | `post_dataroom_trust_center_by_slug_requests`                   |
| **Auth**      | `Authorization: Bearer $HANZO_API_KEY`                          |

Records a request to read what an independent auditor signed, and
answers with its id.

The org that owns the centre decides. Nothing is released here and no link is
minted: this writes the ask down, which is the whole promise the form makes.
The write is the answer — a request that could not be stored is an error, never
a receipt, so a form can never appear to have been sent and be gone.

`email` is required and is the ONLY address the eventual grant will admit, so an
address the asker cannot read is an ask that cannot be answered. Where the centre
states an NDA, `accept` must be true and the text in force is recorded verbatim
against the request.

Asking twice for the same thing from the same address is the SAME ask: the second
answers with the first's id rather than opening a second row, which is also what
keeps an anonymous endpoint from filling a tenant's store.

## Request

7 fields, body `application/json` (required).

| Field    | In   | Type    | Required | Description                                                                            |
| -------- | ---- | ------- | -------- | -------------------------------------------------------------------------------------- |
| `slug`   | path | string  | yes      | Slug is the centre's public address, taken from the path.                              |
| `accept` | body | boolean | —        | Accept must be true when the centre states an NDA.                                     |
| `email`  | body | string  | —        | Email is where the grant will be sent, and the ONLY address the resulting link admits. |
| `item`   | body | string  | —        | Item names one published item to ask for.                                              |
| `party`  | body | string  | —        | Party is the company the asker is from.                                                |
| `reason` | body | string  | —        | Reason is why they want it.                                                            |
| `slug`   | body | string  | —        | Slug is the centre's public address, taken from the path.                              |

## Response

| Status    | Body                | Meaning |
| --------- | ------------------- | ------- |
| `200`     | dataroom.trustAsked | ok      |
| `default` | problem-details     | refused |

`200` body — 2 fields.

| Field   | In   | Type   | Always | Description                                                      |
| ------- | ---- | ------ | ------ | ---------------------------------------------------------------- |
| `id`    | body | string | —      | ID is the request's id, so the asker can be told about it later. |
| `state` | body | string | —      | State is always "open": recording an ask decides nothing.        |

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

## Examples

**CLI**

```bash
hanzo dataroom trust center requests <slug>
```

**SDK**

**.ts**

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

const api = new DataroomApi(new Configuration({ accessToken: process.env.HANZO_API_KEY }));
const { data } = await api.postDataroomTrustCenterBySlugRequests({ slug: 'slug', accept: false, email: "<email>" });
```

**.py**

```python
from hanzoai.cloud import ApiClient, Configuration
from hanzoai.cloud.api import DataroomApi

client = ApiClient(Configuration(access_token=os.environ["HANZO_API_KEY"]))
result = DataroomApi(client).post_dataroom_trust_center_by_slug_requests(slug='slug', accept=False, email="<email>")
```

**.go**

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

resp, _, err := client.DataroomAPI.PostDataroomTrustCenterBySlugRequests(context.Background()).Execute()
if err != nil {
	return err
}
```

**.rs**

```rust
use hanzo_client::apis::{configuration::Configuration, dataroom_api};

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

let result = dataroom_api::post_dataroom_trust_center_by_slug_requests(&cfg, Default::default()).await?;
```

**.java**

```java
import ai.hanzo.cloud.ApiClient;
import ai.hanzo.cloud.api.DataroomApi;

ApiClient client = new ApiClient();
client.setBearerToken(System.getenv("HANZO_API_KEY"));

var result = new DataroomApi(client).postDataroomTrustCenterBySlugRequests();
```

**HTTP**

```bash
curl -X POST https://api.hanzo.ai/v1/dataroom/trust/center/<slug>/requests \
  -H "Authorization: Bearer $HANZO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
       "accept": false,
       "email": "<email>"
     }'
```

**MCP**

MCP reaches **dataroom** through the `dataroom` tool, which names its 19 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": "get_dataroom_analytic_dataroom"
         }
       }
     }'
```

---

[Dataroom API](https://docs.hanzo.ai/docs/openapi/dataroom) · [All Hanzo APIs](https://docs.hanzo.ai/docs/openapi) · [Interactive reference](https://docs.hanzo.ai/docs/openapi/reference)