# Create refuse

URL: https://docs.hanzo.ai/docs/openapi/dataroom/post-dataroom-trust-requests-by-id-refuse

> Answers a request by declining it, recording who declined and why.

`POST /v1/dataroom/trust/requests/{id}/refuse`

> [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/requests/{id}/refuse` |
| **Method**    | `POST`                                                        |
| **Operation** | `post_dataroom_trust_requests_by_id_refuse`                   |
| **Auth**      | `Authorization: Bearer $HANZO_API_KEY`                        |

Answers a request by declining it, recording who declined and why.

Nothing is released and no link is minted. The refusal STAYS on the record beside
the ask — a request that was turned down is part of the access record exactly as
one that was granted is, and deleting it would leave a queue that only ever shows
the decisions somebody liked.

A request that was already answered is refused rather than answered twice. Only an
admin of the org may call it, and the request is resolved in that org's own store,
so another org's request id is not found.

## Request

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

| Field  | In   | Type            | Required | Description                                       |
| ------ | ---- | --------------- | -------- | ------------------------------------------------- |
| `id`   | path | string          | yes      | ID is the request to answer, taken from the path. |
| `days` | body | integer (int64) | —        | Days is how long the grant stays open, from now.  |
| `id`   | body | string          | —        | ID is the request to answer, taken from the path. |
| `note` | body | string          | —        | Note is why.                                      |

## Response

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

`200` body — 1 field.

| Field   | In   | Type   | Always | Description         |
| ------- | ---- | ------ | ------ | ------------------- |
| `state` | body | string | —      | State is "refused". |

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

## Examples

**CLI**

```bash
hanzo dataroom trust requests refuse <id>
```

**SDK**

**.ts**

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

const api = new DataroomApi(new Configuration({ accessToken: process.env.HANZO_API_KEY }));
const { data } = await api.postDataroomTrustRequestsByIdRefuse({ id: 'id', days: 0, id: "<id>" });
```

**.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_requests_by_id_refuse(id='id', days=0, id="<id>")
```

**.go**

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

resp, _, err := client.DataroomAPI.PostDataroomTrustRequestsByIdRefuse(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_requests_by_id_refuse(&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).postDataroomTrustRequestsByIdRefuse();
```

**HTTP**

```bash
curl -X POST https://api.hanzo.ai/v1/dataroom/trust/requests/<id>/refuse \
  -H "Authorization: Bearer $HANZO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
       "days": 0,
       "id": "<id>"
     }'
```

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