# VGGT-1B API

> Återskapar en 3D-scen från upp till 48 bilder eller en video och returnerar djupkartor, kameraposer och ett punktmoln

Uppskattar geometri från flera vyer. Ange upp till 48 bilder i `image_urls` och lägg eventuellt till en `video_url` som samplas var `frame_sampling_rate`:e bildruta. Returnerar djupkartor per bildruta, kamerans extrinsiska och intrinsiska parametrar, råa prediktionsfiler samt ett GLB-punktmoln med kamerakoner. `confidence_percentile` och `max_points` styr punktmolnets täthet.

- Model id: `vggt-1b`
- Made by: Meta
- Category: Vision
- Output: json
- Charged by usage (up to $1.755 per run, typical $0.04; the rest of the hold is refunded): $0.000975 / second of processing time (cheapest run $0.04 (40 API credits))
- Run: `POST https://api.doitong.com/v1/run/vggt-1b`
- Quote: `POST https://api.doitong.com/v1/quote/vggt-1b`
- Docs page: https://doitong.com/sv/developers/models/vggt-1b

## Pricing

Price: **$0.000975 / second of processing time**. Charged by actual usage at $0.000975 / second of processing time: up to $1.755 per run (the quote gives the maximum for your input), the rest is refunded automatically after the run. A typical run costs $0.04.

The full example input below holds up to $1.755 = 1755 API credits (up to 1800 s of processing time × $0.000975) when it starts; a typical run costs $0.04 (40 API credits).

Prices are the upstream price in USD, paid from the API balance in API credits (1000 API credits = 1 USD). This model is charged by usage: `POST https://api.doitong.com/v1/quote/vggt-1b` with the same JSON body returns the most the run can cost for that input (`credits`, debited when the run starts); after the run you pay the usage the model reports and the rest is refunded automatically. An input whose maximum would exceed the per-run limit is refused with 422. Invalid input is never charged and failed or canceled requests are refunded automatically.

## Input parameters

Send either the canonical name or the native field name (not both). Canonical names are the same across models.

| Parameter | Canonical name | Type | Required | Default | Allowed values / range | Description |
|---|---|---|---|---|---|---|
| `image_urls` | `images` | array of image URL | no |  | ≤ 48 items | Källbilder för rekonstruktion, där varje bild får utfyllnad till en kvadrat och skalas om så att den längsta dimensionen blir 518 pixlar. JPEG, PNG, WEBP och alla ytterligare bildformat som Pillow kan avkoda stöds. |
| `video_url` | `video` | string (video URL) \| null | no |  |  | Valfri källvideo vars samplade bildrutor följer image_urls i den kombinerade indatan. Sampling använder var `frame_sampling_rate`:e bildruta och inkluderar alltid den första och sista bildrutan. |
| `frame_sampling_rate` |  | integer | no | `24` | 1 – 1,000 | Bildruteintervallet används endast när en video tillhandahålls via `video_url`; annars har det ingen effekt. Båda gränsbildrutorna behålls oavsett intervallet, och var n:te bildruta samplas däremellan. |
| `alpha_blend_onto` |  | enum (string) | no | `white` | `keep`, `white`, `black`, `mean` | Hantering av alfakanalen erbjuder fyra alternativ: 'keep' tar bort alfa utan att ändra de ursprungliga pixelvärdena; 'mean' komponerar mot ImageNets genomsnittliga RGB. För en enfärgad bakgrund väljer du 'white' eller 'black' för att komponera mot motsvarande färg. |
| `export_prediction_data` |  | boolean | no | `true` |  | Exportera råa prediktioner som separata JSON-filer för enskilda bildrutor. Varje fil innehåller djup och dess konfidens, en mask samt den kodade kameraställningen. |
| `export_depth_maps` |  | boolean | no | `true` |  | Exportera djuprastrar med en linjär mappning av `depth_range` till pixelvärdena 0–65535. Varje bildruta får en separat gråskalig PNG med 16-bitars precision. |
| `export_point_cloud` |  | boolean | no | `true` |  | Exportera det sammanslagna färgade punktmolnet i GLB-format, där uppskattade kameror representeras av individuella koniska meshobjekt i scenen. |
| `array_encoding` |  | enum (string) | no | `base64` | `base64`, `list` | Lagringsformat för arrayer i prediktions-JSON-filer, där 'list' tar betydligt mer utrymme än 'base64'. Välj 'list' för nästlade JSON-listor eller 'base64' för objekt som innehåller {data, shape, dtype}. |
| `exclude_keys` |  | array of enum (string) | no |  |  | Nycklar som undantas från varje prediktions-JSON-fil. |
| `confidence_percentile` |  | number | no | `50` | 0 – 100 | Konfidensbaserad filtreringsprocent för konstruktion av punktmoln: 0 inaktiverar filtrering, medan andra värden exkluderar den procentandelen punkter, med början från de minst säkra. |
| `max_points` |  | integer | no | `250000` | 1,000 – 5,000,000 | Maximalt antal punkter i GLB, med standardvärdet 250,000. För att minska serialiserings- och uppladdningsfördröjningen skrivs ett jämnt nedsamplat urval när molnet överskrider denna budget. |
| `enable_safety_checker` |  | boolean | no | `true` |  | Växling för säkerhetskontroll av indatabilder och video. |

File parameters (`images`, `video`) take a public `https://` URL, a `data:` URI up to 10 MB, or the `file_url` of an upload from `POST /files`.

## Example input

Required parameters only:

```json
{}
```

A fuller example:

```json
{}
```

## Run it

Set `DOITONG_API_KEY` to a key from https://doitong.com/developers/dashboard#keys. `?wait=20` returns the finished request in the same call when it is ready within 20 seconds; otherwise poll `GET /requests/{id}` (it also accepts `?wait=`), or pass `webhook_url`.

### curl

```bash
# Run the model; wait up to 20 s for the finished result in the same call
curl -X POST "https://api.doitong.com/v1/run/vggt-1b?wait=20" \
  -H "Authorization: Bearer $DOITONG_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{}'

# Still "queued" or "running"? Poll with the id from the response:
curl "https://api.doitong.com/v1/requests/REQUEST_ID?wait=20" \
  -H "Authorization: Bearer $DOITONG_API_KEY"
```

### JavaScript

```javascript
const API = "https://api.doitong.com/v1";
const headers = {
  "Authorization": "Bearer " + process.env.DOITONG_API_KEY,
  "Content-Type": "application/json",
};

// Run the model; wait up to 20 s for the finished result in the same call
let res = await fetch(API + "/run/vggt-1b?wait=20", {
  method: "POST",
  headers,
  body: JSON.stringify({}),
});
let request = await res.json();
if (!res.ok) throw new Error(request.error.code + ": " + request.error.message);

// Not finished yet: long-poll until it is
while (request.status === "queued" || request.status === "running") {
  res = await fetch(API + "/requests/" + request.id + "?wait=20", { headers });
  request = await res.json();
}
if (request.status !== "succeeded") throw new Error(JSON.stringify(request.error));
console.log(request.outputs.map((o) => o.url), request.cost.credits + " API credits ($" + request.cost.usd + ")");
```

### Python

```python
import os
import requests

API = "https://api.doitong.com/v1"
headers = {"Authorization": "Bearer " + os.environ["DOITONG_API_KEY"]}

payload = {}

# Run the model; wait up to 20 s for the finished result in the same call
r = requests.post(API + "/run/vggt-1b", params={"wait": 20}, json=payload, headers=headers)
request = r.json()
if not r.ok:
    raise RuntimeError(request["error"]["code"] + ": " + request["error"]["message"])

# Not finished yet: long-poll until it is
while request["status"] in ("queued", "running"):
    request = requests.get(API + "/requests/" + request["id"], params={"wait": 20}, headers=headers).json()
if request["status"] != "succeeded":
    raise RuntimeError(request["error"])
print([o["url"] for o in request["outputs"]], request["cost"]["credits"], "API credits", "$" + request["cost"]["usd"])
```

### MCP

The MCP server at `https://api.doitong.com/v1/mcp` exposes the tools `search_models`, `get_model`, `quote`, `run`, `get_request`, `cancel_request`, `list_requests`, `create_upload` and `get_account`. A `run` call for this model:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "run",
    "arguments": {
      "model_id": "vggt-1b",
      "input": {},
      "wait_seconds": 20
    }
  }
}
```

## Response

Every call returns a request object. `status` is one of `queued`, `running`, `succeeded`, `failed`, `canceled`. `outputs` lists the generated files with URLs on our storage (kept forever, or 7 days with `?storage=temporary`; `storage` says which); `output` is the model's own result object with the same URLs.

```json
{
  "id": "req_8k2m4q7x1z9c3v5b6n0p2r4t",
  "object": "request",
  "model": "vggt-1b",
  "status": "succeeded",
  "created_at": "2026-10-20T12:00:00Z",
  "started_at": "2026-10-20T12:00:02Z",
  "completed_at": "2026-10-20T12:00:09Z",
  "queue_position": null,
  "cost": {
    "credits": 1755,
    "usd": "1.755",
    "charged": 1755,
    "refunded": 0
  },
  "input": {},
  "output": {
    "point_cloud": {
      "url": "https://content.doitong.com/dev-api/2026/10/20/req_8k2m4q7x1z9c3v5b6n0p2r4t/0-output.jpeg",
      "content_type": "image/jpeg",
      "file_name": "0-output.jpeg",
      "file_size": 1843200
    },
    "depth_maps": [
      {
        "url": "https://content.doitong.com/dev-api/2026/10/20/req_8k2m4q7x1z9c3v5b6n0p2r4t/0-output.jpeg",
        "content_type": "image/jpeg",
        "file_name": "0-output.jpeg",
        "file_size": 1843200,
        "width": 1024,
        "height": 768
      }
    ],
    "prediction_data": [
      {
        "url": "https://content.doitong.com/dev-api/2026/10/20/req_8k2m4q7x1z9c3v5b6n0p2r4t/0-output.jpeg",
        "content_type": "image/jpeg",
        "file_name": "0-output.jpeg",
        "file_size": 1843200
      }
    ],
    "num_frames": 1,
    "depth_range": [
      1.0
    ],
    "extrinsics": [
      [
        [
          1.0
        ]
      ]
    ],
    "intrinsics": [
      [
        [
          1.0
        ]
      ]
    ],
    "timings": {}
  },
  "outputs": [
    {
      "type": "file",
      "url": "https://content.doitong.com/dev-api/2026/10/20/req_8k2m4q7x1z9c3v5b6n0p2r4t/0-output.jpeg",
      "content_type": "image/jpeg",
      "file_size": 1843200,
      "stored": true
    }
  ],
  "error": null,
  "metrics": {
    "inference_seconds": 6.8
  },
  "urls": {
    "self": "https://api.doitong.com/v1/requests/req_8k2m4q7x1z9c3v5b6n0p2r4t",
    "cancel": "https://api.doitong.com/v1/requests/req_8k2m4q7x1z9c3v5b6n0p2r4t/cancel"
  }
}
```

### Output fields (`output`)

| Field | Type | Description |
|---|---|---|
| `point_cloud` | object {url, content_type, file_name, file_size} \| null | Punktmolnsexport som returneras när `export_point_cloud` är true; dess GLB-scen kombinerar det sammanslagna molnet med kamerakoner. |
| `depth_maps` | array of object {url, content_type, file_name, file_size, width, height} | Djupkarteexport som är tillgänglig när `export_depth_maps` är true. Poster följer källans bildrutesekvens, där varje bildruta representeras av en gråskalig PNG-raster med 16-bitars djup. |
| `prediction_data` | array of object {url, content_type, file_name, file_size} | Export av råa prediktioner: när `export_prediction_data` är true har varje bildruta en egen JSON-fil, och filerna följer bildrutesekvensen. |
| `num_frames` | integer | Totalt antal rekonstruerade bildrutor, inklusive bilder och bildrutor som samplats från video. |
| `depth_range` | array of number | Djupgränser [min, max] som används för kvantisering av `depth_maps`. Återskapa djupet som min + pixel * (max - min) / 65535. |
| `extrinsics` | array of array of array of number | Extrinsiska matriser från kamera till värld, med storleken 3x4, för varje bildruta; OpenCV-axlarna pekar åt höger längs x, nedåt längs y och framåt längs z. |
| `intrinsics` | array of array of array of number | Pinhole-intrinsiska matriser, med storleken 3x3, för varje bildruta, uttryckta i pixelkoordinaterna för modellens bildruta på 518x518. |
| `timings` | object | Förfluten väggklocketid för varje steg, i sekunder. |

## Related models

- [Sam 3 · Image · Embed](https://doitong.com/developers/models/sam-3/image/embed.md) (`sam-3/image/embed`): $0.005 / run
- [Bagel · Understand](https://doitong.com/developers/models/bagel/understand.md) (`bagel/understand`): $0.05 / request
- [Bria Ad Delayer](https://doitong.com/developers/models/bria/ad-delayer.md) (`bria/ad-delayer`): $0.30 / request
- [Florence 2 Large Caption](https://doitong.com/developers/models/florence-2-large/caption.md) (`florence-2-large/caption`): $0.003 / run
- [Florence 2 Large Detailed Caption](https://doitong.com/developers/models/florence-2-large/detailed-caption.md) (`florence-2-large/detailed-caption`): $0.004 / run
- [Florence 2 Large OCR](https://doitong.com/developers/models/florence-2-large/ocr.md) (`florence-2-large/ocr`): $0.003 / run
- [Florence 2 Large Region To Category](https://doitong.com/developers/models/florence-2-large/region-to-category.md) (`florence-2-large/region-to-category`): $0.003 / run
- [Florence-2 Large · More Detailed Caption](https://doitong.com/developers/models/florence-2-large/more-detailed-caption.md) (`florence-2-large/more-detailed-caption`): $0.004 / run

## Links

- HTML page: https://doitong.com/developers/models/vggt-1b
- All models and guides for AI agents: https://doitong.com/developers/llms.txt
- OpenAPI 3.1 with this model's typed request body: https://doitong.com/developers/openapi.json?model=vggt-1b
- Errors: https://doitong.com/developers/docs/errors
- Model details as JSON: https://api.doitong.com/v1/models/vggt-1b