# Snelstart

Voer je eerste generatie uit in enkele minuten. Alle 1.496 modellen gebruiken hetzelfde type request en retourneren hetzelfde requestobject voor afbeeldingen, video en audio: leer het hier één keer.

> [!NOTE]
> Basis-URL `https://api.doitong.com/v1`. Elke aanroep verzendt `Authorization: Bearer <your key>`, en dezelfde sleutel werkt voor de HTTP
> API en de MCP-server.

## 1. Een API-sleutel ophalen

Maak een sleutel aan op [https://doitong.com/developers/dashboard#keys](https://doitong.com/developers/dashboard#keys) en bewaar deze in een
environmentvariabele: hij wordt maar één keer weergegeven. Elke sleutel kan een eigen budget hebben, zodat je er een aan een agent kunt geven zonder risico voor het volledige account. `GET /account` retourneert je API-saldo.

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

curl "https://api.doitong.com/v1/account" \
  -H "Authorization: Bearer $DOITONG_API_KEY"
```
```javascript
const res = await fetch("https://api.doitong.com/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.com/v1/account",
    headers={"Authorization": f"Bearer {os.environ['DOITONG_API_KEY']}"},
)
print(r.json())
```

Runs worden betaald uit het **API-saldo** van je account in API-credits: 1.000 API-tegoed = $ 1, en elk model kost exact de prijs van de maker. Waardeer op via [https://doitong.com/developers/dashboard#balance](https://doitong.com/developers/dashboard#balance).

## 2. Offerte opvragen en vervolgens uitvoeren

`POST /quote/{model_id}` neemt de JSON-invoer en retourneert de exacte prijs. Er is geen sleutel nodig en er zijn geen kosten aan verbonden. Dezelfde invoer uitvoeren kost precies dat bedrag: de offerte is de afschrijving. (Een model dat op basis van gebruik wordt afgerekend is de uitzondering: de offerte is het maximale bedrag dat de run kan kosten, en het ongebruikte deel wordt na de run terugbetaald.)

```bash
curl -X POST "https://api.doitong.com/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.com/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.com/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 · offerte
{
  "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"
}
```

Verzend vervolgens dezelfde body naar `POST /run/{model_id}`. Voeg `?wait=20` toe om de verbinding maximaal 20 seconden open te houden: een snel model retourneert het voltooide resultaat in één roundtrip. Verzend een `Idempotency-Key`-header zodat een retry nooit twee keer wordt uitgevoerd (of in rekening gebracht).

```bash
curl -X POST "https://api.doitong.com/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.com/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.com/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)
```

De response is een requestobject:

```json 200 OK · request
{
  "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. De status volgen

Als het model nog bezig is wanneer de wachttijd eindigt, ontvang je `202 Accepted` met de `id` en huidige `status` van het request. Elk request doorloopt dezelfde levenscyclus:

Levenscyclus van een request: `queued` → `running` → `succeeded` | `failed` | `canceled` (definitief; mislukte en geannuleerde aanvragen worden terugbetaald).

Lees het request opnieuw met zijn id. `?wait=20` werkt hier ook, dus een eenvoudige lus volstaat:

```bash
curl "https://api.doitong.com/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.com/v1/requests/req_8k2m4q7x1z9c3v5b6n0p2r4t?wait=20", { headers })).json();

while (request.status === "queued" || request.status === "running") {
  const res = await fetch(`https://api.doitong.com/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.com/v1/requests/{request['id']}",
        params={"wait": 20},
        headers=headers,
    ).json()

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

Wanneer `status` `succeeded` is, bevat `outputs[].url` links naar de bestanden in onze opslag. Als het request `failed` of `canceled` is, worden de API-credits automatisch terugbetaald en geeft `error` de reden aan. Annuleer alles wat nog `queued` of `running` is:

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

Voor lange videoruns kun je polling overslaan en in plaats daarvan een `webhook_url` doorgeven (zie [Webhooks](https://doitong.com/developers/docs/webhooks)).

## 4. Bestanden

Geef een openbare URL door als invoer, of vraag `POST /files` om een upload-URL, voer daar een `PUT` uit met het bestand en gebruik de geretourneerde `file_url` (zie [Bestanden](https://doitong.com/developers/docs/files)). Een geslaagd request vermeldt de resultaten in `outputs[]` met type, contenttype en, indien bekend, afmetingen en duur.

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

> [!TIP]
> **Bestanden voor altijd bewaren, of 7 dagen gratis: jij kiest.** Uitvoerbestanden worden naar onze opslag gekopieerd voordat een request slaagt. Standaard blijven ze staan totdat je ze verwijdert (100 API-credits
> per GB per maand); schakel "Bestanden voor altijd bewaren" uit in het dashboard, of geef `?storage=temporary` door, om ze
> 7 dagen gratis te bewaren (zie [Bestanden](https://doitong.com/developers/docs/files#storage)).

## Fouten

Elk model mislukt op dezelfde manier: één envelop met een `type`, een exacte `code`, de betreffende `param` en elk probleem in `details`, zodat een agent het request kan herstellen zonder proza te lezen. Voor een ongeldig request worden geen kosten in rekening gebracht.

```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"
  }
}
```

Elk type en elke code staat vermeld in [Fouten](https://doitong.com/developers/docs/errors).

## Prijzen

Prijzen zijn in USD en API-credits en worden vóór uitvoering op elke modelpagina weergegeven. Elk request bevat `cost` met `credits`, `usd`, `charged` en `refunded`. Een run wordt in rekening gebracht zodra deze is geaccepteerd; `failed` en `canceled` requests worden automatisch terugbetaald. Sommige modellen worden exact op basis van de invoer geprijsd, sommige op basis van de lengte of grootte van de bestanden die je verzendt, en bij andere geldt een *geschatte prijs per run*: in alle gevallen is de offerte het bedrag dat je betaalt. Enkele modellen (taal- en visiemodellen, spraak- en verwerkingstijdtools) worden *op basis van gebruik afgerekend*: de offerte is het maximale bedrag dat de run kan kosten, en het deel dat de run niet heeft gebruikt wordt automatisch terugbetaald. Zie [Prijzen](https://doitong.com/developers/docs/pricing).

## MCP en AI-agents

Verbind elke MCP-client met `https://api.doitong.com/v1/mcp` met dezelfde Bearer-sleutel. Je agent kan de catalogus doorzoeken, offertes opvragen en modellen uitvoeren, en elke documentatiepagina als Markdown lezen.

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

## Volgende stappen

- Bekijk [alle modellen](https://doitong.com/developers/models). Elke pagina heeft een requestbuilder die de code voor je schrijft.
- Leer de levenscyclus van een request: [Requests](https://doitong.com/developers/docs/requests).
- Gebruik dezelfde parameternamen voor elk model: [Parameters](https://doitong.com/developers/docs/parameters).
- Werk je met een AI-codeeragent? Geef hem [https://doitong.com/developers/llms.txt](https://doitong.com/developers/llms.txt) of verbind de [MCP-server](https://doitong.com/developers/docs/mcp).