# त्वरित शुरुआत

कुछ मिनटों में अपना पहला निर्माण चलाएँ। सभी 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 · quote
{
  "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` (अंतिम; विफल और रद्द किए गए अनुरोधों के API क्रेडिट वापस कर दिए जाते हैं).

उसकी 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` भेज सकते हैं ([Webhooks](https://doitong.com/developers/docs/webhooks) देखें)।

## 4. फ़ाइलें

किसी भी सार्वजनिक URL को इनपुट के रूप में भेजें, या अपलोड URL के लिए `POST /files` का अनुरोध करें, वहाँ फ़ाइल को `PUT` करें और लौटाए गए `file_url` का उपयोग करें ([Files](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 प्रति माह); डैशबोर्ड में "फ़ाइलें हमेशा के लिए रखें" को बंद करें, या उन्हें 7 दिनों तक निःशुल्क रखने के लिए
> `?storage=temporary` भेजें ([Files](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"
  }
}
```

हर प्रकार और कोड [Errors](https://doitong.com/developers/docs/errors) में सूचीबद्ध है।

## मूल्य निर्धारण

कीमतें USD और API क्रेडिट में होती हैं और चलाने से पहले हर मॉडल पेज पर दिखाई जाती हैं। हर अनुरोध में `cost` के साथ `credits`, `usd`, `charged` और `refunded` होते हैं। अनुरोध स्वीकार होने पर रन का शुल्क लिया जाता है; `failed` और `canceled` अनुरोधों का अपने-आप रिफंड हो जाता है। कुछ मॉडल इनपुट के आधार पर सटीक कीमत लेते हैं, कुछ आपके द्वारा भेजी गई फ़ाइलों की लंबाई या आकार के आधार पर, और अन्य प्रति रन *अनुमानित कीमत* लेते हैं: किसी भी स्थिति में आप कोट में दी गई राशि ही चुकाते हैं। कुछ मॉडल (भाषा और विज़न मॉडल, वॉइस तथा प्रोसेसिंग-समय टूल) *उपयोग के आधार पर शुल्क लेते हैं*: कोट रन की अधिकतम लागत होती है, और रन द्वारा उपयोग न की गई राशि अपने-आप रिफंड कर दी जाती है। [Pricing](https://doitong.com/developers/docs/pricing) देखें।

## MCP और AI एजेंट

किसी भी MCP क्लाइंट को उसी Bearer कुंजी के साथ `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) देखें। हर पेज पर एक अनुरोध बिल्डर है, जो आपके लिए कोड लिखता है।
- अनुरोध का जीवनचक्र जानें: [Requests](https://doitong.com/developers/docs/requests)।
- हर मॉडल पर वही पैरामीटर नाम इस्तेमाल करें: [Parameters](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) से कनेक्ट करें।