# ਤੁਰੰਤ ਸ਼ੁਰੂਆਤ

ਕੁਝ ਮਿੰਟਾਂ ਵਿੱਚ ਆਪਣੀ ਪਹਿਲੀ ਸਿਰਜਣਾ ਚਲਾਓ। ਸਾਰੇ 1,496 ਮਾਡਲ ਇੱਕੋ ਕਿਸਮ ਦੀ ਬੇਨਤੀ ਲੈਂਦੇ ਹਨ ਅਤੇ ਚਿੱਤਰਾਂ, ਵੀਡੀਓ ਅਤੇ ਆਡੀਓ ਲਈ
ਇੱਕੋ ਬੇਨਤੀ ਆਬਜੈਕਟ ਵਾਪਸ ਕਰਦੇ ਹਨ: ਇਸਨੂੰ ਇੱਥੇ ਇੱਕ ਵਾਰ ਸਿੱਖੋ।

> [!NOTE]
> ਬੇਸ URL `https://api.doitong.ru/v1`। ਹਰ ਕਾਲ `Authorization: Bearer <your key>` ਭੇਜਦੀ ਹੈ, ਅਤੇ ਇੱਕੋ ਕੁੰਜੀ HTTP
> API ਅਤੇ MCP ਸਰਵਰ ਦੋਵਾਂ ਲਈ ਕੰਮ ਕਰਦੀ ਹੈ।

## 1. API ਕੁੰਜੀ ਪ੍ਰਾਪਤ ਕਰੋ

[https://doitong.com/developers/dashboard#keys](https://doitong.com/developers/dashboard#keys) 'ਤੇ ਇੱਕ ਕੁੰਜੀ ਬਣਾਓ ਅਤੇ ਇਸਨੂੰ ਇੱਕ
ਵਾਤਾਵਰਣ ਵੈਰੀਏਬਲ ਵਿੱਚ ਰੱਖੋ: ਇਹ ਸਿਰਫ਼ ਇੱਕ ਵਾਰ ਦਿਖਾਈ ਜਾਂਦੀ ਹੈ। ਹਰ ਕੁੰਜੀ ਦਾ ਆਪਣਾ ਬਜਟ ਹੋ ਸਕਦਾ ਹੈ, ਇਸ ਲਈ ਤੁਸੀਂ ਪੂਰੇ ਖਾਤੇ ਨੂੰ
ਖਤਰੇ ਵਿੱਚ ਪਾਏ ਬਿਨਾਂ ਇੱਕ ਏਜੰਟ ਨੂੰ ਕੁੰਜੀ ਦੇ ਸਕਦੇ ਹੋ। `GET /account` ਤੁਹਾਡਾ API ਬਕਾਇਆ ਵਾਪਸ ਕਰਦਾ ਹੈ।

```bash
export DOITONG_API_KEY="doitong_..."

curl "https://api.doitong.ru/v1/account" \
  -H "Authorization: Bearer $DOITONG_API_KEY"
```
```javascript
const res = await fetch("https://api.doitong.ru/v1/account", {
  headers: { Authorization: `Bearer ${process.env.DOITONG_API_KEY}` },
});

console.log(await res.json());
```
```python
import os
import requests

r = requests.get(
    "https://api.doitong.ru/v1/account",
    headers={"Authorization": f"Bearer {os.environ['DOITONG_API_KEY']}"},
)
print(r.json())
```

ਰਨ ਤੁਹਾਡੇ ਖਾਤੇ ਦੇ **API ਬਕਾਇਆ** ਵਿੱਚੋਂ API ਕ੍ਰੈਡਿਟ ਵਿੱਚ ਭੁਗਤਾਨ ਕੀਤੇ ਜਾਂਦੇ ਹਨ: 1,000 API ਕ੍ਰੈਡਿਟ = $1, ਅਤੇ ਹਰ ਮਾਡਲ ਦੀ ਕੀਮਤ
ਉਸਦੇ ਨਿਰਮਾਤਾ ਵੱਲੋਂ ਨਿਰਧਾਰਤ ਕੀਮਤ ਦੇ ਬਿਲਕੁਲ ਬਰਾਬਰ ਹੁੰਦੀ ਹੈ। [https://doitong.ru/developers/dashboard#balance](https://doitong.ru/developers/dashboard#balance) 'ਤੇ ਬਕਾਇਆ ਭਰੋ।

## 2. ਕੀਮਤ ਲਵੋ, ਫਿਰ ਚਲਾਓ

`POST /quote/{model_id}` ਇਨਪੁੱਟ JSON ਲੈਂਦਾ ਹੈ ਅਤੇ ਸਹੀ ਕੀਮਤ ਵਾਪਸ ਕਰਦਾ ਹੈ। ਇਸ ਲਈ ਕਿਸੇ ਕੁੰਜੀ ਦੀ ਲੋੜ ਨਹੀਂ ਅਤੇ ਕੋਈ ਲਾਗਤ ਨਹੀਂ।
ਉਹੀ ਇਨਪੁੱਟ ਚਲਾਉਣ ਦੀ ਲਾਗਤ ਬਿਲਕੁਲ ਇੰਨੀ ਹੀ ਹੁੰਦੀ ਹੈ: ਕੀਮਤ ਹੀ ਚਾਰਜ ਹੁੰਦੀ ਹੈ। (ਵਰਤੋਂ ਅਨੁਸਾਰ ਚਾਰਜ ਹੋਣ ਵਾਲਾ ਮਾਡਲ ਅਪਵਾਦ ਹੈ: ਉਸਦੀ
ਕੀਮਤ ਰਨ ਦੀ ਵੱਧ ਤੋਂ ਵੱਧ ਸੰਭਵ ਲਾਗਤ ਹੁੰਦੀ ਹੈ ਅਤੇ ਨਾ ਵਰਤਿਆ ਗਿਆ ਹਿੱਸਾ ਰਨ ਤੋਂ ਬਾਅਦ ਵਾਪਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।)

```bash
curl -X POST "https://api.doitong.ru/v1/quote/kling-video/v3/pro/image-to-video" \
  -H "Content-Type: application/json" \
  -d '{"image": "https://example.com/fox.jpg", "duration": 5, "generate_audio": true}'
```
```javascript
const res = await fetch("https://api.doitong.ru/v1/quote/kling-video/v3/pro/image-to-video", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({ image: "https://example.com/fox.jpg", duration: 5, generate_audio: true }),
});

const quote = await res.json();
console.log(quote.credits, quote.usd); // 840 "0.84"
```
```python
import requests

r = requests.post(
    "https://api.doitong.ru/v1/quote/kling-video/v3/pro/image-to-video",
    json={"image": "https://example.com/fox.jpg", "duration": 5, "generate_audio": True},
)
print(r.json()["credits"], r.json()["usd"])  # 840 0.84
```

```json 200 OK · ਕੀਮਤ
{
  "object": "quote",
  "model": "kling-video/v3/pro/image-to-video",
  "credits": 840,
  "usd": "0.84",
  "unit": "second",
  "quantity": 5,
  "unit_credits": 168,
  "mode": "exact",
  "breakdown": "5 s × 168 API credits"
}
```

ਫਿਰ ਉਹੀ ਬਾਡੀ `POST /run/{model_id}` ਨੂੰ ਭੇਜੋ। ਕਨੈਕਸ਼ਨ ਨੂੰ ਵੱਧ ਤੋਂ ਵੱਧ 20 ਸਕਿੰਟਾਂ ਲਈ ਰੋਕਣ ਵਾਸਤੇ `?wait=20` ਜੋੜੋ: ਤੇਜ਼
ਮਾਡਲ ਇੱਕ ਹੀ ਰਾਊਂਡ ਟ੍ਰਿਪ ਵਿੱਚ ਪੂਰਾ ਨਤੀਜਾ ਵਾਪਸ ਕਰ ਦਿੰਦਾ ਹੈ। `Idempotency-Key` ਹੈਡਰ ਭੇਜੋ ਤਾਂ ਜੋ ਦੁਬਾਰਾ ਕੋਸ਼ਿਸ਼ ਕਰਨ 'ਤੇ ਰਨ ਕਦੇ ਵੀ ਦੋ ਵਾਰ ਨਾ ਚੱਲੇ (ਜਾਂ
ਦੋ ਵਾਰ ਚਾਰਜ ਨਾ ਹੋਵੇ)।

```bash
curl -X POST "https://api.doitong.ru/v1/run/flux/schnell?wait=20" \
  -H "Authorization: Bearer $DOITONG_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: lighthouse-001" \
  -d '{"prompt": "A lighthouse on a rocky coast at dusk, warm light in the window"}'
```
```javascript
const res = await fetch("https://api.doitong.ru/v1/run/flux/schnell?wait=20", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.DOITONG_API_KEY}`,
    "Content-Type": "application/json",
    "Idempotency-Key": "lighthouse-001",
  },
  body: JSON.stringify({ prompt: "A lighthouse on a rocky coast at dusk, warm light in the window" }),
});

const request = await res.json();
console.log(request.status, request.outputs[0]?.url);
```
```python
import os
import requests

r = requests.post(
    "https://api.doitong.ru/v1/run/flux/schnell",
    params={"wait": 20},
    headers={
        "Authorization": f"Bearer {os.environ['DOITONG_API_KEY']}",
        "Idempotency-Key": "lighthouse-001",
    },
    json={"prompt": "A lighthouse on a rocky coast at dusk, warm light in the window"},
)
request = r.json()
print(request["status"], request["outputs"][0]["url"] if request["outputs"] else None)
```

ਜਵਾਬ ਇੱਕ ਬੇਨਤੀ ਆਬਜੈਕਟ ਹੁੰਦਾ ਹੈ:

```json 200 OK · ਬੇਨਤੀ
{
  "id": "req_8k2m4q7x1z9c3v5b6n0p2r4t",
  "object": "request",
  "model": "flux/schnell",
  "status": "succeeded",
  "cost": { "credits": 3, "usd": "0.003", "charged": 3, "refunded": 0 },
  "outputs": [
    { "type": "image", "url": "https://content.doitong.com/dev-api/2026/10/20/req_8k2m4q7x1z9c3v5b6n0p2r4t/0-output.jpeg",
      "content_type": "image/jpeg", "width": 1024, "height": 768, "stored": true }
  ],
  "error": null
}
```

## 3. ਸਥਿਤੀ ਦਾ ਪਾਲਣ ਕਰੋ

ਜੇ ਉਡੀਕ ਖਤਮ ਹੋਣ 'ਤੇ ਮਾਡਲ ਹਾਲੇ ਵੀ ਕੰਮ ਕਰ ਰਿਹਾ ਹੋਵੇ, ਤਾਂ ਤੁਹਾਨੂੰ ਬੇਨਤੀ ਦੀ `id` ਅਤੇ ਮੌਜੂਦਾ
`status` ਨਾਲ `202 Accepted` ਮਿਲਦਾ ਹੈ। ਹਰ ਬੇਨਤੀ ਇੱਕੋ ਜੀਵਨ-ਚੱਕਰ ਵਿੱਚੋਂ ਲੰਘਦੀ ਹੈ:

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

ਇਸਦੀ id ਨਾਲ ਬੇਨਤੀ ਨੂੰ ਦੁਬਾਰਾ ਪੜ੍ਹੋ। ਇੱਥੇ ਵੀ `?wait=20` ਕੰਮ ਕਰਦਾ ਹੈ, ਇਸ ਲਈ ਇੱਕ ਸਧਾਰਨ ਲੂਪ ਕਾਫ਼ੀ ਹੈ:

```bash
curl "https://api.doitong.ru/v1/requests/req_8k2m4q7x1z9c3v5b6n0p2r4t?wait=20" \
  -H "Authorization: Bearer $DOITONG_API_KEY"
```
```javascript
const headers = { Authorization: `Bearer ${process.env.DOITONG_API_KEY}` };
let request = await (await fetch("https://api.doitong.ru/v1/requests/req_8k2m4q7x1z9c3v5b6n0p2r4t?wait=20", { headers })).json();

while (request.status === "queued" || request.status === "running") {
  const res = await fetch(`https://api.doitong.ru/v1/requests/${request.id}?wait=20`, { headers });
  request = await res.json();
}

console.log(request.status, request.outputs[0]?.url);
```
```python
import os
import requests

headers = {"Authorization": f"Bearer {os.environ['DOITONG_API_KEY']}"}
request = {"id": "req_8k2m4q7x1z9c3v5b6n0p2r4t", "status": "queued"}

while request["status"] in ("queued", "running"):
    request = requests.get(
        f"https://api.doitong.ru/v1/requests/{request['id']}",
        params={"wait": 20},
        headers=headers,
    ).json()

print(request["status"], request["outputs"][0]["url"] if request["outputs"] else None)
```

ਜਦੋਂ `status` `succeeded` ਹੋਵੇ, ਤਾਂ `outputs[].url` ਸਾਡੇ ਸਟੋਰੇਜ ਵਿੱਚ ਮੌਜੂਦ ਫ਼ਾਈਲਾਂ ਦੇ ਲਿੰਕ ਰੱਖਦਾ ਹੈ। ਜੇ ਬੇਨਤੀ `failed` ਜਾਂ
`canceled` ਹੋਵੇ, ਤਾਂ ਇਸਦੇ API ਕ੍ਰੈਡਿਟ ਆਪਣੇ-ਆਪ ਵਾਪਸ ਕਰ ਦਿੱਤੇ ਜਾਂਦੇ ਹਨ ਅਤੇ `error` ਕਾਰਨ ਦੱਸਦਾ ਹੈ। `queued` ਜਾਂ
`running` ਵਿੱਚ ਮੌਜੂਦ ਕਿਸੇ ਵੀ ਚੀਜ਼ ਨੂੰ ਰੱਦ ਕਰੋ:

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

ਲੰਬੇ ਵੀਡੀਓ ਕੰਮਾਂ ਲਈ ਤੁਸੀਂ ਪੋਲਿੰਗ ਛੱਡ ਕੇ ਇਸਦੀ ਬਜਾਏ `webhook_url` ਭੇਜ ਸਕਦੇ ਹੋ (ਵੇਖੋ [ਵੈੱਬਹੁੱਕ](https://doitong.com/developers/docs/webhooks))।

## 4. ਫ਼ਾਈਲਾਂ

ਕਿਸੇ ਵੀ ਜਨਤਕ URL ਨੂੰ ਇਨਪੁੱਟ ਵਜੋਂ ਭੇਜੋ, ਜਾਂ ਅੱਪਲੋਡ URL ਲਈ `POST /files` ਨੂੰ ਕਹੋ, ਫ਼ਾਈਲ ਉੱਥੇ `PUT` ਕਰੋ ਅਤੇ ਵਾਪਸ ਮਿਲਿਆ
`file_url` ਵਰਤੋ (ਵੇਖੋ [ਫ਼ਾਈਲਾਂ](https://doitong.com/developers/docs/files))। ਸਫਲ ਬੇਨਤੀ ਆਪਣੇ ਨਤੀਜੇ `outputs[]` ਵਿੱਚ
ਕਿਸਮ, ਸਮੱਗਰੀ ਦੀ ਕਿਸਮ ਅਤੇ, ਜਦੋਂ ਪਤਾ ਹੋਵੇ, ਮਾਪ ਅਤੇ ਮਿਆਦ ਸਮੇਤ ਦਰਸਾਉਂਦੀ ਹੈ।

```bash
curl -X POST "https://api.doitong.ru/v1/files" \
  -H "Authorization: Bearer $DOITONG_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"filename": "fox.jpg", "content_type": "image/jpeg", "size": 482113}'
```

> [!TIP]
> **ਫ਼ਾਈਲਾਂ ਹਮੇਸ਼ਾ ਲਈ ਰੱਖੋ, ਜਾਂ 7 ਦਿਨ ਮੁਫ਼ਤ: ਤੁਹਾਡੀ ਚੋਣ।** ਬੇਨਤੀ ਸਫਲ ਹੋਣ ਤੋਂ ਪਹਿਲਾਂ ਆਉਟਪੁੱਟ ਫ਼ਾਈਲਾਂ ਸਾਡੇ
> ਸਟੋਰੇਜ ਵਿੱਚ ਕਾਪੀ ਕੀਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ। ਪੂਰਵ-ਨਿਰਧਾਰਤ ਤੌਰ 'ਤੇ ਉਹ ਉਦੋਂ ਤੱਕ ਰਹਿੰਦੀਆਂ ਹਨ ਜਦੋਂ ਤੱਕ ਤੁਸੀਂ ਉਨ੍ਹਾਂ ਨੂੰ ਮਿਟਾ ਨਹੀਂ ਦਿੰਦੇ (100 API ਕ੍ਰੈਡਿਟ
> ਪ੍ਰਤੀ GB ਪ੍ਰਤੀ ਮਹੀਨਾ); ਡੈਸ਼ਬੋਰਡ ਵਿੱਚ "ਫ਼ਾਈਲਾਂ ਹਮੇਸ਼ਾ ਲਈ ਰੱਖੋ" ਨੂੰ ਬੰਦ ਕਰੋ, ਜਾਂ `?storage=temporary` ਭੇਜੋ, ਤਾਂ ਜੋ ਉਹਨਾਂ ਨੂੰ
> 7 ਦਿਨ ਮੁਫ਼ਤ ਰੱਖਿਆ ਜਾ ਸਕੇ (ਵੇਖੋ [ਫ਼ਾਈਲਾਂ](https://doitong.com/developers/docs/files#storage))।

## ਤਰੁੱਟੀਆਂ

ਹਰ ਮਾਡਲ ਇੱਕੋ ਤਰੀਕੇ ਨਾਲ ਅਸਫਲ ਹੁੰਦਾ ਹੈ: `type`, ਸਹੀ `code`, ਸਮੱਸਿਆ ਪੈਦਾ ਕਰਨ ਵਾਲਾ `param` ਅਤੇ `details` ਵਿੱਚ ਹਰ ਸਮੱਸਿਆ ਵਾਲਾ
ਇੱਕ ਐਨਵਲਪ, ਤਾਂ ਜੋ ਕੋਈ ਏਜੰਟ ਗੱਥਾ ਪੜ੍ਹੇ ਬਿਨਾਂ ਬੇਨਤੀ ਠੀਕ ਕਰ ਸਕੇ। ਅਵੈਧ ਬੇਨਤੀ ਲਈ ਕੋਈ ਚਾਰਜ ਨਹੀਂ ਲੱਗਦਾ।

```json 422 Unprocessable Entity
{
  "error": {
    "type": "invalid_request",
    "code": "invalid_input",
    "message": "duration must be one of 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15.",
    "param": "duration",
    "details": [ { "param": "duration", "message": "duration must be one of 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15." } ],
    "request_id": null,
    "doc_url": "https://doitong.com/developers/docs/errors#invalid_input"
  }
}
```

ਹਰ ਕਿਸਮ ਅਤੇ ਕੋਡ [ਤਰੁੱਟੀਆਂ](https://doitong.com/developers/docs/errors) ਵਿੱਚ ਸੂਚੀਬੱਧ ਹੈ।

## ਕੀਮਤ

ਕੀਮਤਾਂ USD ਅਤੇ API ਕ੍ਰੈਡਿਟ ਵਿੱਚ ਹੁੰਦੀਆਂ ਹਨ ਅਤੇ ਚਲਾਉਣ ਤੋਂ ਪਹਿਲਾਂ ਹਰ ਮਾਡਲ ਪੰਨੇ 'ਤੇ ਦਿਖਾਈਆਂ ਜਾਂਦੀਆਂ ਹਨ। ਹਰ ਬੇਨਤੀ `cost` ਵਿੱਚ
`credits`, `usd`, `charged` ਅਤੇ `refunded` ਰੱਖਦੀ ਹੈ। ਬੇਨਤੀ ਸਵੀਕਾਰ ਹੋਣ 'ਤੇ ਚਾਰਜ ਲੱਗਦਾ ਹੈ; `failed` ਅਤੇ `canceled` ਬੇਨਤੀਆਂ
ਆਪਣੇ-ਆਪ ਵਾਪਸ ਕੀਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ। ਕੁਝ ਮਾਡਲਾਂ ਦੀ ਕੀਮਤ ਇਨਪੁੱਟ ਤੋਂ ਬਿਲਕੁਲ ਨਿਰਧਾਰਤ ਹੁੰਦੀ ਹੈ, ਕੁਝ ਤੁਹਾਡੇ ਵੱਲੋਂ ਭੇਜੀਆਂ ਫ਼ਾਈਲਾਂ ਦੀ
ਲੰਬਾਈ ਜਾਂ ਆਕਾਰ ਅਨੁਸਾਰ, ਜਦਕਿ ਹੋਰਾਂ ਲਈ *ਪ੍ਰਤੀ ਰਨ ਅੰਦਾਜ਼ੀ ਕੀਮਤ* ਲੱਗਦੀ ਹੈ: ਕਿਸੇ ਵੀ ਤਰੀਕੇ ਨਾਲ, ਤੁਸੀਂ ਉਹੀ ਕੀਮਤ ਅਦਾ ਕਰਦੇ ਹੋ। ਕੁਝ
ਮਾਡਲ (ਭਾਸ਼ਾ ਅਤੇ ਵਿਜ਼ਨ ਮਾਡਲ, ਆਵਾਜ਼, ਪ੍ਰੋਸੈਸਿੰਗ-ਸਮੇਂ ਦੇ ਟੂਲ) *ਵਰਤੋਂ ਅਨੁਸਾਰ ਚਾਰਜ* ਹੁੰਦੇ ਹਨ: ਕੀਮਤ ਰਨ ਦੀ ਵੱਧ ਤੋਂ ਵੱਧ ਸੰਭਵ ਲਾਗਤ ਹੁੰਦੀ ਹੈ ਅਤੇ
ਰਨ ਵੱਲੋਂ ਨਾ ਵਰਤਿਆ ਗਿਆ ਹਿੱਸਾ ਆਪਣੇ-ਆਪ ਵਾਪਸ ਕਰ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ। [ਕੀਮਤ](https://doitong.com/developers/docs/pricing) ਵੇਖੋ।

## MCP ਅਤੇ AI ਏਜੰਟ

ਉਸੇ Bearer ਕੁੰਜੀ ਨਾਲ ਕਿਸੇ ਵੀ MCP ਕਲਾਇੰਟ ਨੂੰ `https://api.doitong.ru/v1/mcp` ਨਾਲ ਕਨੈਕਟ ਕਰੋ। ਤੁਹਾਡਾ ਏਜੰਟ ਕੈਟਾਲਾਗ ਖੋਜ ਸਕਦਾ ਹੈ, ਮਾਡਲਾਂ ਦੀ ਕੀਮਤ ਲੈ ਕੇ
ਉਨ੍ਹਾਂ ਨੂੰ ਚਲਾ ਸਕਦਾ ਹੈ ਅਤੇ ਹਰ ਦਸਤਾਵੇਜ਼ ਪੰਨੇ ਨੂੰ Markdown ਵਜੋਂ ਪੜ੍ਹ ਸਕਦਾ ਹੈ।

```bash Claude Code
claude mcp add --transport http doitong-models https://api.doitong.ru/v1/mcp \
  --header "Authorization: Bearer YOUR_API_KEY"
```

## ਅਗਲੇ ਕਦਮ

- [ਸਾਰੇ ਮਾਡਲਾਂ](https://doitong.com/developers/models) ਨੂੰ ਬ੍ਰਾਊਜ਼ ਕਰੋ। ਹਰ ਪੰਨੇ 'ਤੇ ਇੱਕ ਬੇਨਤੀ ਬਿਲਡਰ ਹੈ ਜੋ ਤੁਹਾਡੇ ਲਈ ਕੋਡ ਲਿਖਦਾ ਹੈ।
- ਬੇਨਤੀ ਦਾ ਜੀਵਨ-ਚੱਕਰ ਸਿੱਖੋ: [ਬੇਨਤੀਆਂ](https://doitong.com/developers/docs/requests)।
- ਹਰ ਮਾਡਲ 'ਤੇ ਇੱਕੋ ਪੈਰਾਮੀਟਰ ਨਾਮ ਵਰਤੋ: [ਪੈਰਾਮੀਟਰ](https://doitong.com/developers/docs/parameters)।
- ਕੀ ਤੁਸੀਂ AI ਕੋਡਿੰਗ ਏਜੰਟ ਨਾਲ ਕੰਮ ਕਰ ਰਹੇ ਹੋ? ਇਸਨੂੰ [https://doitong.com/developers/llms.txt](https://doitong.com/developers/llms.txt) ਦਿਓ ਜਾਂ [MCP ਸਰਵਰ](https://doitong.com/developers/docs/mcp) ਨਾਲ ਕਨੈਕਟ ਕਰੋ।