# ਬੇਨਤੀਆਂ

ਇੱਕ ਬੇਨਤੀ ਇੱਕ ਮਾਡਲ ਦੀ ਇੱਕ ਕਾਲ ਹੈ। ਇਸਦੀ ਇੱਕ id (`req_…`), ਇੱਕ ਸਥਿਤੀ, API ਕ੍ਰੈਡਿਟ ਵਿੱਚ ਇਸਦੀ ਲਾਗਤ (1000 = 1 USD), ਅਤੇ ਸਫਲ ਹੋਣ 'ਤੇ, ਤਿਆਰ ਕੀਤੀਆਂ ਫ਼ਾਈਲਾਂ ਹੁੰਦੀਆਂ ਹਨ। ਹਰੇਕ ਮਾਡਲ ਲਈ, ਹੇਠਾਂ ਦਿੱਤੇ ਹਰੇਕ ਐਂਡਪੋਇੰਟ ਤੋਂ ਇਹੀ ਆਬਜੈਕਟ ਵਾਪਸ ਆਉਂਦਾ ਹੈ।

## ਇੱਕ ਮਾਡਲ ਲੱਭੋ

ਸਾਰੇ 1,496 ਮਾਡਲਾਂ ਦਾ ਕੈਟਾਲਾਗ ਜਨਤਕ JSON ਹੈ (ਕਿਸੇ ਕੁੰਜੀ ਦੀ ਲੋੜ ਨਹੀਂ):

```bash
curl "https://api.doitong.ru/v1/models?category=text-to-video&lab=Google&limit=20"
```

| ਕੁਏਰੀ ਪੈਰਾਮੀਟਰ | ਮਤਲਬ |
|---|---|
| `q` | ਉਹ ਸ਼ਬਦ ਜੋ ਨਾਮ, id, ਨਿਰਮਾਤਾ ਜਾਂ ਟੈਗਸ ਵਿੱਚ ਦਿਖਾਈ ਦੇਣੇ ਚਾਹੀਦੇ ਹਨ, ਉਦਾਹਰਨ ਲਈ `kling 3`। |
| `category` | ਇੱਕ ਸ਼੍ਰੇਣੀ id, ਉਦਾਹਰਨ ਲਈ `text-to-video` ਜਾਂ `upscale`। `GET https://api.doitong.ru/v1/categories` ਸਾਰੇ 21 ਨੂੰ ਉਹਨਾਂ ਦੀ ਗਿਣਤੀ ਦੇ ਨਾਲ ਸੂਚੀਬੱਧ ਕਰਦਾ ਹੈ। |
| `lab` | ਮਾਡਲ ਦਾ ਨਿਰਮਾਤਾ, ਨਾਮ ਜਾਂ id ਦੁਆਰਾ, ਉਦਾਹਰਨ ਲਈ `Google` ਜਾਂ `black-forest-labs`। |
| `family` | ਪਿਛਲੀ ਕਤਾਰ ਤੋਂ ਇੱਕ `family` id: ਇੱਕ ਮਾਡਲ ਦੇ ਹਰੇਕ ਰੂਪ (pro, fast, image-to-video, …)। |
| `mode` | `exact` (ਕੀਮਤ ਇਨਪੁੱਟ ਤੋਂ ਗਣਨਾ ਕੀਤੀ ਜਾਂਦੀ ਹੈ), `measured` (ਇਨਪੁੱਟ ਫ਼ਾਈਲਾਂ ਦੀ ਲੰਬਾਈ ਜਾਂ ਆਕਾਰ ਤੋਂ), `estimate` (ਪ੍ਰਤੀ ਰਨ ਇੱਕ ਅਨੁਮਾਨਿਤ ਕੀਮਤ) ਜਾਂ `metered` (ਅਸਲ ਵਰਤੋਂ ਦੁਆਰਾ ਚਾਰਜ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਪ੍ਰਤੀ ਰਨ ਅਧਿਕਤਮ ਤੱਕ)। |
| `limit`, `cursor` | ਪੇਜ ਦਾ ਆਕਾਰ (1 ਤੋਂ 100, ਪੂਰਵ-ਨਿਰਧਾਰਤ 50) ਅਤੇ ਪਿਛਲੇ ਪੇਜ ਦਾ `next_cursor`। |

ਹਰੇਕ ਕਤਾਰ ਵਿੱਚ `id`, `name`, `lab`, `category`, `family`, `summary`, `tags`, `output_kind`, `docs_url` ਅਤੇ ਇੱਕ `price` ਆਬਜੈਕਟ ਹੁੰਦਾ ਹੈ ([Pricing](https://doitong.com/developers/docs/pricing#price-objects) ਦੇਖੋ)। `GET https://api.doitong.ru/v1/models/{model_id}` ਪੂਰਾ ਇਨਪੁੱਟ ਅਤੇ ਆਉਟਪੁੱਟ JSON Schema, ਪ੍ਰਮਾਣਿਕ ਪੈਰਾਮੀਟਰ ਨਾਮ, ਕੀਮਤ ਦੇ ਨਿਯਮ ਅਤੇ ਇੱਕ ਉਦਾਹਰਨ ਇਨਪੁੱਟ ਜੋੜਦਾ ਹੈ। ਇੱਕ ਅਣਜਾਣ `category` ਜਾਂ `mode` `400 invalid_parameter` ਹੁੰਦਾ ਹੈ।

## ਇੱਕ ਮਾਡਲ ਚਲਾਓ

```bash
curl -X POST "https://api.doitong.ru/v1/run/{model_id}?wait=20" \
  -H "Authorization: Bearer $DOITONG_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: order-1842-cover" \
  -d '{"prompt": "..."}'
```

- ਬੌਡੀ ਮਾਡਲ ਇਨਪੁੱਟ ਹੈ, ਇੱਕ JSON ਆਬਜੈਕਟ। ਹਰੇਕ ਮਾਡਲ ਪੇਜ ਇਸਦੇ ਪੈਰਾਮੀਟਰਾਂ ਨੂੰ ਸੂਚੀਬੱਧ ਕਰਦਾ ਹੈ।
- ਕੁਝ ਵੀ ਚਾਰਜ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਇਨਪੁੱਟ ਦੀ ਜਾਂਚ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਇੱਕ ਅਵੈਧ ਇਨਪੁੱਟ ਗਲਤ `param` ਦੇ ਨਾਲ `422 invalid_input` ਵਾਪਸ ਕਰਦਾ ਹੈ, ਅਤੇ ਕੁਝ ਵੀ ਖਰਚ ਨਹੀਂ ਹੁੰਦਾ।
- `?wait=N` (20 ਸਕਿੰਟ ਤੱਕ) ਕਾਲ ਨੂੰ ਉਦੋਂ ਤੱਕ ਰੋਕ ਕੇ ਰੱਖਦਾ ਹੈ ਜਦੋਂ ਤੱਕ ਬੇਨਤੀ ਪੂਰੀ ਨਹੀਂ ਹੋ ਜਾਂਦੀ ਜਾਂ ਸਮਾਂ ਖਤਮ ਨਹੀਂ ਹੋ ਜਾਂਦੀ।
- ਜਦੋਂ ਬੇਨਤੀ ਪੂਰੀ ਹੋ ਜਾਂਦੀ ਹੈ ਤਾਂ `?webhook_url=https://…` ਉਸ URL 'ਤੇ ਇੱਕ ਹਸਤਾਖਰਿਤ POST ਭੇਜਦਾ ਹੈ ([Webhooks](https://doitong.com/developers/docs/webhooks) ਦੇਖੋ)।
- `?storage=permanent` ਜਾਂ `?storage=temporary` ਚੁਣਦਾ ਹੈ ਕਿ ਆਉਟਪੁੱਟ ਫ਼ਾਈਲਾਂ ਨੂੰ ਕਿੰਨੀ ਦੇਰ ਤੱਕ ਰੱਖਿਆ ਜਾਣਾ ਹੈ; ਇਸ ਤੋਂ ਬਿਨਾਂ ਖਾਤਾ ਸੈਟਿੰਗ ਲਾਗੂ ਹੁੰਦੀ ਹੈ ([ਫ਼ਾਈਲਾਂ ਕਿੱਥੇ ਰਹਿੰਦੀਆਂ ਹਨ](#storage) ਦੇਖੋ)।

ਜਦੋਂ ਬੇਨਤੀ ਅਜੇ ਵੀ ਕੰਮ ਕਰ ਰਹੀ ਹੁੰਦੀ ਹੈ ਤਾਂ ਜਵਾਬ `202 Accepted` ਹੁੰਦਾ ਹੈ, ਅਤੇ ਜਦੋਂ ਇਹ ਉਡੀਕ ਦੇ ਅੰਦਰ ਪੂਰੀ ਹੋ ਜਾਂਦੀ ਹੈ (ਜਾਂ ਜਦੋਂ ਇਹ ਰੀਪਲੇਅ ਹੁੰਦੀ ਹੈ, ਹੇਠਾਂ ਦੇਖੋ) ਤਾਂ `200 OK` ਹੁੰਦਾ ਹੈ। `Location` ਅਤੇ `Doitong-Request-Id` ਹੈਡਰ ਬੇਨਤੀ URL ਅਤੇ id ਲੈ ਕੇ ਜਾਂਦੇ ਹਨ।

## ਸਥਿਤੀਆਂ

ਬੇਨਤੀ ਦਾ ਲਾਈਫ਼ਸਾਈਕਲ: `queued` → `running` → `succeeded` | `failed` | `canceled` (ਅੰਤਿਮ; ਅਸਫਲ ਅਤੇ ਰੱਦ ਕੀਤੇ ਗਏ ਰਿਫੰਡ ਕੀਤੇ ਜਾਂਦੇ ਹਨ).

| ਸਥਿਤੀ | ਮਤਲਬ | ਅੰਤਿਮ |
|---|---|---|
| `queued` | ਸਵੀਕਾਰ ਕੀਤਾ ਗਿਆ ਅਤੇ ਚਾਰਜ ਕੀਤਾ ਗਿਆ, ਵਰਕਰ ਦੀ ਉਡੀਕ ਕਰ ਰਿਹਾ ਹੈ। `queue_position` ਲਾਈਨ ਵਿੱਚ ਸਥਾਨ ਦਿਖਾ ਸਕਦਾ ਹੈ। | ਨਹੀਂ |
| `running` | ਮਾਡਲ ਜਨਰੇਟ ਕਰ ਰਿਹਾ ਹੈ। | ਨਹੀਂ |
| `succeeded` | ਹੋ ਗਿਆ। `outputs` ਫ਼ਾਈਲਾਂ ਨੂੰ ਸੂਚੀਬੱਧ ਕਰਦਾ ਹੈ। | ਹਾਂ |
| `failed` | ਮਾਡਲ ਜਾਂ ਕਿਸੇ ਸੀਮਾ ਨੇ ਇਸਨੂੰ ਰੋਕ ਦਿੱਤਾ। `error` ਦੱਸਦਾ ਹੈ ਕਿ ਕਿਉਂ। API ਕ੍ਰੈਡਿਟ ਦੀ ਰਕਮ ਵਾਪਸੀ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। | ਹਾਂ |
| `canceled` | ਨਤੀਜਾ ਨਿਕਲਣ ਤੋਂ ਪਹਿਲਾਂ ਰੱਦ ਕਰ ਦਿੱਤਾ ਗਿਆ। API ਕ੍ਰੈਡਿਟ ਦੀ ਰਕਮ ਵਾਪਸੀ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। | ਹਾਂ |

ਇੱਕ ਬੇਨਤੀ ਜੋ ਆਪਣੀ ਸਮਾਂ ਸੀਮਾ ਤੋਂ ਵੱਧ ਚੱਲਦੀ ਹੈ, `timeout` ਕੋਡ ਨਾਲ ਅਸਫਲ ਹੋ ਜਾਂਦੀ ਹੈ ਅਤੇ ਰਕਮ ਵਾਪਸੀ ਕੀਤੀ ਜਾਂਦੀ ਹੈ: ਚਿੱਤਰਾਂ ਲਈ 15 ਮਿੰਟ, ਵੀਡੀਓ ਲਈ 60 ਮਿੰਟ, ਆਡੀਓ ਅਤੇ ਬਾਕੀ ਸਭ ਕੁਝ ਲਈ 30 ਮਿੰਟ।

## ਬੇਨਤੀ ਆਬਜੈਕਟ

```json
{
  "id": "req_8k2m4q7x1z9c3v5b6n0p2r4t",
  "object": "request",
  "model": "flux/schnell",
  "status": "succeeded",
  "created_at": "2026-10-20T12:00:00Z",
  "started_at": "2026-10-20T12:00:01Z",
  "completed_at": "2026-10-20T12:00:02Z",
  "queue_position": null,
  "cost": { "credits": 3, "usd": "0.003", "charged": 3, "refunded": 0 },
  "input": { "prompt": "..." },
  "output": { "images": [ { "url": "https://content.doitong.com/dev-api/…/0-output.jpeg", "width": 1024, "height": 768 } ] },
  "outputs": [
    { "type": "image", "url": "https://content.doitong.com/dev-api/…/0-output.jpeg", "content_type": "image/jpeg",
      "width": 1024, "height": 768, "file_size": 183920, "stored": true }
  ],
  "error": null,
  "metrics": { "inference_seconds": 1.2 },
  "storage": { "mode": "permanent", "bytes": 183920, "expires_at": null, "expired": false },
  "urls": {
    "self": "https://api.doitong.ru/v1/requests/req_8k2m4q7x1z9c3v5b6n0p2r4t",
    "cancel": "https://api.doitong.ru/v1/requests/req_8k2m4q7x1z9c3v5b6n0p2r4t/cancel"
  }
}
```

- `outputs` ਹਰੇਕ ਮਾਡਲ ਲਈ ਇੱਕੋ ਜਿਹਾ ਹੁੰਦਾ ਹੈ: `type` (`image`, `video`, `audio`, `file` ਜਾਂ `3d`), ਸਾਡੀ ਸਟੋਰੇਜ 'ਤੇ ਇੱਕ `url`, `content_type` ਅਤੇ, ਜਦੋਂ ਪਤਾ ਹੋਵੇ, `file_size`, `width`, `height`, `duration` ਦੇ ਨਾਲ ਹਰੇਕ ਤਿਆਰ ਕੀਤੀ ਫ਼ਾਈਲ ਲਈ ਇੱਕ ਐਂਟਰੀ।
- `output` ਮਾਡਲ ਦਾ ਆਪਣਾ ਨਤੀਜਾ ਆਬਜੈਕਟ ਹੈ (ਇਸਦੇ ਫੀਲਡ ਹਰੇਕ ਮਾਡਲ ਪੇਜ 'ਤੇ ਸੂਚੀਬੱਧ ਹਨ) ਜਿਸ ਵਿੱਚ ਉਹੀ URL ਹੁੰਦੇ ਹਨ।
- `storage` ਦੱਸਦਾ ਹੈ ਕਿ ਫ਼ਾਈਲਾਂ ਨੂੰ ਕਿਵੇਂ ਰੱਖਿਆ ਜਾਂਦਾ ਹੈ: `mode` (`permanent` ਜਾਂ `temporary`), ਸਟੋਰ ਕੀਤੇ `bytes`, `expires_at` (ਜਦੋਂ ਇੱਕ ਅਸਥਾਈ ਫ਼ਾਈਲ ਮਿਟਾ ਦਿੱਤੀ ਜਾਂਦੀ ਹੈ, ਸਥਾਈ ਫ਼ਾਈਲਾਂ ਲਈ `null`) ਅਤੇ `expired` (ਫ਼ਾਈਲਾਂ ਚਲੇ ਜਾਣ ਤੋਂ ਬਾਅਦ `true`)।
- `cost.credits` API ਕ੍ਰੈਡਿਟ ਵਿੱਚ ਕਾਲ ਦੀ ਕੀਮਤ ਹੈ (`cost.usd` USD ਵਿੱਚ), `cost.charged` ਉਹ ਹੈ ਜੋ API ਬਕਾਇਆ ਵਿੱਚੋਂ ਕੱਟਿਆ ਗਿਆ ਸੀ, `cost.refunded` ਉਹ ਹੈ ਜੋ ਵਾਪਸ ਆਇਆ ਸੀ। ਇੱਕ `metered` ਮਾਡਲ ਲਈ `cost.credits` ਸ਼ੁਰੂ ਵਿੱਚ ਰੱਖੀ ਗਈ ਅਧਿਕਤਮ ਰਾਸ਼ੀ ਹੈ (`cost.held`); ਇੱਕ ਵਾਰ ਰਨ ਸਫਲ ਹੋਣ 'ਤੇ `cost.settled` ਦੱਸਦਾ ਹੈ ਕਿ ਵਰਤੋਂ ਕਿੰਨੀ ਹੋਈ ਅਤੇ ਬਾਕੀ ਅਧਿਕਤਮ ਰਾਸ਼ੀ `cost.refunded` ਵਿੱਚ ਹੁੰਦੀ ਹੈ ([ਵਰਤੋਂ ਦੁਆਰਾ ਚਾਰਜ ਕੀਤਾ ਗਿਆ](https://doitong.com/developers/docs/pricing#metered) ਦੇਖੋ)।
- ਜਦੋਂ ਕੋਈ ਬੇਨਤੀ ਅਸਫਲ ਹੁੰਦੀ ਹੈ, ਤਾਂ `error` `{ "type": …, "code": …, "message": … }` ਹੁੰਦਾ ਹੈ।

## ਇੱਕ ਬੇਨਤੀ ਪੜ੍ਹੋ

```bash
curl "https://api.doitong.ru/v1/requests/req_8k2m4q7x1z9c3v5b6n0p2r4t?wait=20" \
  -H "Authorization: Bearer $DOITONG_API_KEY"
```

- `?wait=N` (20 ਸਕਿੰਟ ਤੱਕ) ਲੌਂਗ-ਪੋਲ: ਕਾਲ ਉਦੋਂ ਹੀ ਵਾਪਸ ਆਉਂਦੀ ਹੈ ਜਦੋਂ ਬੇਨਤੀ ਅੰਤਿਮ ਹੁੰਦੀ ਹੈ, ਜਾਂ ਮੌਜੂਦਾ ਸਥਿਤੀ ਦੇ ਨਾਲ N ਸਕਿੰਟਾਂ ਬਾਅਦ। ਨਤੀਜੇ ਦੀ ਉਡੀਕ ਕਰਨ ਲਈ ਇਸ 'ਤੇ ਲੂਪ ਕਰਨਾ ਸਭ ਤੋਂ ਸਰਲ ਤਰੀਕਾ ਹੈ।
- `?logs=1` ਮਾਡਲ ਦੀ ਪ੍ਰਗਤੀ ਦੀਆਂ ਲੌਗ ਲਾਈਨਾਂ (ਆਖਰੀ 50) ਨੂੰ `logs` ਵਜੋਂ ਜੋੜਦਾ ਹੈ।

ਤੁਸੀਂ ਸਿਰਫ਼ ਆਪਣੇ ਖਾਤੇ ਦੀਆਂ ਬੇਨਤੀਆਂ ਪੜ੍ਹ ਸਕਦੇ ਹੋ; ਕੋਈ ਹੋਰ id `404 request_not_found` ਹੈ।

## ਬੇਨਤੀਆਂ ਦੀ ਸੂਚੀ ਬਣਾਓ

```bash
curl "https://api.doitong.ru/v1/requests?limit=20&status=succeeded&model=flux/schnell" \
  -H "Authorization: Bearer $DOITONG_API_KEY"
```

ਸਭ ਤੋਂ ਨਵਾਂ ਪਹਿਲਾਂ। `limit` 1 ਤੋਂ 100 ਹੈ (ਪੂਰਵ-ਨਿਰਧਾਰਤ 20), `status` ਅਤੇ `model` ਫਿਲਟਰ। ਜਵਾਬ `{ "object": "list", "data": [ … ], "has_more": true, "next_cursor": "req_…" }` ਹੈ; ਅਗਲੇ ਪੇਜ ਲਈ `cursor=<next_cursor>` ਪਾਸ ਕਰੋ।

## ਇੱਕ ਬੇਨਤੀ ਰੱਦ ਕਰੋ

```bash
curl -X POST "https://api.doitong.ru/v1/requests/req_8k2m4q7x1z9c3v5b6n0p2r4t/cancel" \
  -H "Authorization: Bearer $DOITONG_API_KEY"
```

- ਮਾਡਲ ਸ਼ੁਰੂ ਹੋਣ ਤੋਂ ਪਹਿਲਾਂ ਰੱਦ ਕੀਤਾ ਗਿਆ: ਸਥਿਤੀ `canceled` ਹੋ ਜਾਂਦੀ ਹੈ, API ਕ੍ਰੈਡਿਟ ਦੀ ਰਕਮ ਵਾਪਸੀ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਅਤੇ ਤੁਹਾਨੂੰ `200` ਮਿਲਦਾ ਹੈ।
- ਪਹਿਲਾਂ ਹੀ ਜਨਰੇਟ ਹੋ ਰਿਹਾ ਹੈ: ਰੱਦ ਕਰਨ ਦੀ ਬੇਨਤੀ ਅੱਗੇ ਭੇਜੀ ਜਾਂਦੀ ਹੈ ਅਤੇ ਤੁਹਾਨੂੰ `"cancel_requested": true` ਦੇ ਨਾਲ `202` ਮਿਲਦਾ ਹੈ। ਜੇਕਰ ਮਾਡਲ ਫਿਰ ਵੀ ਪੂਰਾ ਹੋ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਬੇਨਤੀ ਆਮ ਵਾਂਗ ਸਫਲ ਹੁੰਦੀ ਹੈ ਅਤੇ ਚਾਰਜ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।
- ਪਹਿਲਾਂ ਹੀ ਅੰਤਿਮ: `409 not_cancelable` (ਇੱਕ ਬੇਨਤੀ ਜੋ ਪਹਿਲਾਂ ਹੀ `canceled` ਹੈ, ਬਸ `200` ਵਾਪਸ ਕਰਦੀ ਹੈ)।

## ਇੱਕ ਬੇਨਤੀ ਦੀਆਂ ਫ਼ਾਈਲਾਂ ਮਿਟਾਓ

```bash
curl -X DELETE "https://api.doitong.ru/v1/requests/req_8k2m4q7x1z9c3v5b6n0p2r4t/files" \
  -H "Authorization: Bearer $DOITONG_API_KEY"
```

ਬੇਨਤੀ ਦੀਆਂ ਆਉਟਪੁੱਟ ਫ਼ਾਈਲਾਂ ਦੀਆਂ ਸਾਡੀਆਂ ਕਾਪੀਆਂ ਨੂੰ ਹੁਣੇ ਮਿਟਾ ਦਿੰਦਾ ਹੈ ਅਤੇ ਉਹਨਾਂ ਦੇ ਸਟੋਰੇਜ ਚਾਰਜ ਨੂੰ ਰੋਕ ਦਿੰਦਾ ਹੈ। ਜਵਾਬ `storage.expired: true` ਵਾਲਾ ਬੇਨਤੀ ਆਬਜੈਕਟ ਹੈ; ਇਸਦੇ URL ਰਿਕਾਰਡ ਵਿੱਚ ਰਹਿੰਦੇ ਹਨ ਪਰ ਹੁਣ ਕੰਮ ਨਹੀਂ ਕਰਦੇ। ਇਸਨੂੰ ਦੁਬਾਰਾ ਕਾਲ ਕਰਨ ਨਾਲ ਕੁਝ ਨਹੀਂ ਬਦਲਦਾ (`200`)। ਇੱਕ ਬੇਨਤੀ ਜੋ ਅਜੇ ਵੀ `queued` ਜਾਂ `running` ਹੈ, ਉਸਦੀਆਂ ਅਜੇ ਕੋਈ ਫ਼ਾਈਲਾਂ ਨਹੀਂ ਹਨ: `409 request_active`। `models:run` ਦੀ ਲੋੜ ਹੈ।

## Idempotency: ਦੋ ਵਾਰ ਭੁਗਤਾਨ ਕੀਤੇ ਬਿਨਾਂ ਦੁਬਾਰਾ ਕੋਸ਼ਿਸ਼ ਕਰੋ

ਨੈੱਟਵਰਕ ਫੇਲ ਹੋ ਜਾਂਦੇ ਹਨ। ਇੱਕ ਰਨ ਨੂੰ ਸੁਰੱਖਿਅਤ ਢੰਗ ਨਾਲ ਦੁਬਾਰਾ ਕੋਸ਼ਿਸ਼ ਕਰਨ ਲਈ, ਇੱਕ `Idempotency-Key` ਹੈਡਰ ਭੇਜੋ (255 ਅੱਖਰਾਂ ਤੱਕ ਦੀ ਕੋਈ ਵੀ ਸਟ੍ਰਿੰਗ, ਪ੍ਰਤੀ ਓਪਰੇਸ਼ਨ ਵਿਲੱਖਣ, ਉਦਾਹਰਨ ਲਈ ਤੁਹਾਡੀ ਆਪਣੀ ਆਰਡਰ id):

- ਪਹਿਲਾਂ ਵਾਂਗ ਹੀ ਕੁੰਜੀ ਅਤੇ ਉਹੀ ਬੌਡੀ: ਤੁਹਾਨੂੰ ਅਸਲ ਬੇਨਤੀ ਵਾਪਸ ਮਿਲਦੀ ਹੈ (`200`, ਹੈਡਰ `Idempotent-Replayed: true`), ਅਤੇ ਕੁਝ ਵੀ ਦੁਬਾਰਾ ਚਾਰਜ ਨਹੀਂ ਕੀਤਾ ਜਾਂਦਾ।
- ਮਾਡਲ ਤੱਕ ਪਹੁੰਚਣ ਤੋਂ ਪਹਿਲਾਂ ਫੇਲ ਹੋਏ ਰਨ ਤੋਂ ਬਾਅਦ ਉਹੀ ਕੁੰਜੀ ਅਤੇ ਬੌਡੀ (ਸਬਮਿਟ ਕਰਨ 'ਤੇ `upstream_error` ਜਾਂ `internal_error`, `insufficient_credits`, `budget_exceeded`, `too_many_inflight`): ਕੁਝ ਵੀ ਤਿਆਰ ਨਹੀਂ ਕੀਤਾ ਗਿਆ ਸੀ ਅਤੇ ਕੁਝ ਵੀ ਚਾਰਜ ਨਹੀਂ ਕੀਤਾ ਗਿਆ ਸੀ, ਇਸ ਲਈ ਦੁਬਾਰਾ ਕੋਸ਼ਿਸ਼ ਅਸਫਲਤਾ ਵਾਪਸ ਕਰਨ ਦੀ ਬਜਾਏ ਮਾਡਲ ਨੂੰ ਦੁਬਾਰਾ ਚਲਾਉਂਦੀ ਹੈ।
- ਵੱਖਰੀ ਬੌਡੀ ਦੇ ਨਾਲ ਉਹੀ ਕੁੰਜੀ: `409 idempotency_mismatch`।
- ਕੁੰਜੀਆਂ ਉਸ API ਕੁੰਜੀ ਤੱਕ ਸੀਮਿਤ ਹੁੰਦੀਆਂ ਹਨ ਜਿਸਨੇ ਉਹਨਾਂ ਨੂੰ ਭੇਜਿਆ ਸੀ।

## ਫ਼ਾਈਲਾਂ ਕਿੱਥੇ ਰਹਿੰਦੀਆਂ ਹਨ

ਬੇਨਤੀ ਨੂੰ `succeeded` ਵਜੋਂ ਮਾਰਕ ਕੀਤੇ ਜਾਣ ਤੋਂ ਪਹਿਲਾਂ ਹਰੇਕ ਆਉਟਪੁੱਟ ਫ਼ਾਈਲ ਨੂੰ ਸਾਡੀ ਸਟੋਰੇਜ ਵਿੱਚ ਕਾਪੀ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਇਸ ਲਈ `outputs` ਵਿੱਚ URL ਸਾਡੇ ਆਪਣੇ ਹੋਸਟਾਂ 'ਤੇ ਹੁੰਦੇ ਹਨ ਅਤੇ ਤੁਸੀਂ ਉਹਨਾਂ ਨਾਲ ਸਿੱਧਾ ਲਿੰਕ ਕਰ ਸਕਦੇ ਹੋ। ਉਹ ਕਿੰਨੀ ਦੇਰ ਰਹਿੰਦੇ ਹਨ ਇਹ ਤੁਹਾਡੀ ਪਸੰਦ ਹੈ:

| ਮੋਡ | ਕਿੰਨੀ ਦੇਰ | ਕੀਮਤ |
|---|---|---|
| `permanent` (ਪੂਰਵ-ਨਿਰਧਾਰਤ) | ਜਦੋਂ ਤੱਕ ਤੁਸੀਂ ਉਹਨਾਂ ਨੂੰ ਮਿਟਾ ਨਹੀਂ ਦਿੰਦੇ | 100 API ਕ੍ਰੈਡਿਟ ($0.10) ਪ੍ਰਤੀ GB ਪ੍ਰਤੀ ਮਹੀਨਾ, API ਬਕਾਇਆ ਤੋਂ ਰੋਜ਼ਾਨਾ ਚਾਰਜ ਕੀਤਾ ਜਾਂਦਾ ਹੈ |
| `temporary` | 7 ਦਿਨ, ਫਿਰ ਮਿਟਾ ਦਿੱਤਾ ਗਿਆ | ਮੁਫ਼ਤ |

- ਖਾਤਾ ਸੈਟਿੰਗ ਨਵੀਆਂ ਬੇਨਤੀਆਂ ਲਈ ਫੈਸਲਾ ਕਰਦੀ ਹੈ: [ਡੈਸ਼ਬੋਰਡ](https://doitong.com/developers/dashboard#balance) ਵਿੱਚ "ਫ਼ਾਈਲਾਂ ਹਮੇਸ਼ਾ ਲਈ ਰੱਖੋ" ਸਵਿੱਚ, ਜਾਂ `{"mode": "temporary"}` ਦੇ ਨਾਲ `PATCH https://api.doitong.ru/v1/account/storage`। `GET https://api.doitong.ru/v1/account` ਇਸਨੂੰ `storage` ਦੇ ਅਧੀਨ ਦਿਖਾਉਂਦਾ ਹੈ, ਉਹਨਾਂ ਬਾਈਟਾਂ ਅਤੇ ਮਹੀਨਾਵਾਰ ਅਨੁਮਾਨ ਦੇ ਨਾਲ ਜੋ ਤੁਸੀਂ ਰੱਖਦੇ ਹੋ।
- ਇੱਕ ਰਨ 'ਤੇ `?storage=permanent|temporary` (MCP `run` ਟੂਲ ਦਾ `storage` ਆਰਗੂਮੈਂਟ) ਉਸ ਰਨ ਲਈ ਇਸਨੂੰ ਓਵਰਰਾਈਡ ਕਰਦਾ ਹੈ।
- ਸੈਟਿੰਗ ਬਦਲਣ ਨਾਲ ਤੁਹਾਡੇ ਕੋਲ ਪਹਿਲਾਂ ਤੋਂ ਮੌਜੂਦ ਫ਼ਾਈਲਾਂ ਨੂੰ ਕਦੇ ਵੀ ਛੂਹਿਆ ਨਹੀਂ ਜਾਂਦਾ; ਉਹਨਾਂ ਨੂੰ [`DELETE /requests/{id}/files`](#delete-files) ਨਾਲ ਮਿਟਾਓ।
- ਜਦੋਂ API ਬਕਾਇਆ ਸਟੋਰੇਜ ਲਈ ਭੁਗਤਾਨ ਨਹੀਂ ਕਰ ਸਕਦਾ, ਤਾਂ ਕੁਝ ਵੀ ਚਾਰਜ ਨਹੀਂ ਕੀਤਾ ਜਾਂਦਾ ਅਤੇ ਤੁਹਾਨੂੰ ਇੱਕ ਈਮੇਲ ਮਿਲਦੀ ਹੈ: 30 ਦਿਨਾਂ ਦੇ ਅੰਦਰ ਬਕਾਇਆ ਭਰੋ, ਨਹੀਂ ਤਾਂ ਰੱਖੀਆਂ ਗਈਆਂ ਫ਼ਾਈਲਾਂ ਅਸਥਾਈ ਬਣ ਜਾਂਦੀਆਂ ਹਨ ਅਤੇ 7 ਦਿਨਾਂ ਬਾਅਦ ਮਿਟਾ ਦਿੱਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ।

ਬਹੁਤ ਘੱਟ ਮਾਮਲਿਆਂ ਵਿੱਚ ਜੇਕਰ ਸਾਡੀ ਕਾਪੀ ਫੇਲ ਹੋ ਜਾਂਦੀ ਹੈ, ਤਾਂ ਐਂਟਰੀ ਵਿੱਚ `"stored": false` ਹੁੰਦਾ ਹੈ ਅਤੇ URL ਅਸਲੀ, ਥੋੜ੍ਹੇ ਸਮੇਂ ਵਾਲਾ ਹੁੰਦਾ ਹੈ: ਇਸਨੂੰ ਜਲਦੀ ਡਾਊਨਲੋਡ ਕਰੋ।