> For the complete documentation index, see [llms.txt](https://tchek.gitbook.io/documentation/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://tchek.gitbook.io/documentation/master.md).

# Quick Start Guide

## Quick Start Guide

Welcome to the Tchek API documentation. This guide will help you understand the platform, choose your integration path, and make your first API call.

If you have any questions or issues, contact [Tchek Support](mailto:support@tchek.ai).

***

### What is Alto AI?

Alto AI is Tchek's cloud-based vehicle inspection engine. It analyses images of a vehicle and returns a structured list of detected damages, affected parts, severity levels, and repair cost estimates — all in a single JSON response.

Alto AI requires no local computing or storage capacity on your side. You send image URLs; we return results.

### Choosing your integration path

{% tabs %}
{% tab title="API only" %}
**Best for:** teams that already have a front-end and want to plug AI results into their own product.

You call the API directly with a list of image URLs and receive the full JSON inspection result via webhook or polling. You design your own report interface.

**Key endpoints:**

* `POST /damage/vehicle` — submit images, receive damage analysis
* `POST /tokenmanager/token` — generate SSO tokens to embed widgets

**Read next:** API endpoints — Overview
{% endtab %}

{% tab title="Web Widget (iframe)" %}
**Best for:** teams that want to embed Tchek's capture and review flows inside their own web application without building a custom UI.

You generate an SSO token and load the widget in an iframe. Your users perform the inspection inside the Tchek interface; results are returned to you via webhook.

Available widgets: Shoot Inspect, Fast Track, Editable Report, Final Report.

**Read next:** Web Widget — Quick start
{% endtab %}

{% tab title="Hub (no-code)" %}
**Best for:** operations teams who need to run inspections and access results without any development work.

Log in to the Hub at [webapp.tchek.fr](https://webapp.tchek.fr) and start an inspection by uploading images, sending an inspection link to a customer by SMS or email, or starting a direct inspection from the interface.

Results are available immediately in the Hub. Reports can be shared as a web link or downloaded as PDF.

**Read next:** Tchek Self Inspection & Your Flow
{% endtab %}
{% endtabs %}

***

### API basics

#### Endpoint

All API requests are made to the following hostname:

```bash
https://alto.tchek.fr/apiV1/
```

To confirm connectivity:

```bash
curl https://alto.tchek.fr/apiV1/
# {"version":"10.9.128","build":"2022-07-19T13:00:05.548Z"}
```

#### Environments

{% hint style="info" %}
Two environments are available: **preproduction** and **production**. Always develop and test against preproduction before switching to production.

See Environments for hostnames and configuration details.
{% endhint %}

#### Authentication

The Tchek API uses personal access tokens. Include your token in the `X-API-Key` header on every request:

```bash
curl -H "X-API-Key: <your_access_token>" https://alto.tchek.fr/apiV1/...
```

Access tokens are tied to a Tchek company account and carry the same access level as that account. Contact your account manager to obtain a token.

{% hint style="warning" %}
Keep your access token secure. Do not include it in client-side code, emails, or public repositories. If a token is accidentally exposed, revoke it immediately from the Developer settings of your Tchek user account.
{% endhint %}

For full details, see Authentication.

#### Swagger Playground

You can explore and test all endpoints interactively in the Swagger UI — no code required.

{% embed url="<https://alto.tchek.fr/api-docs>" %}

***

### Your first inspection

The fastest way to test the API is to submit a set of vehicle image URLs to the damage detection endpoint.

#### 1. Prepare your images

Images must meet the following requirements for reliable detection:

* Format: `.jpg`, `.jpeg`, or `.png`
* Minimum resolution: **1920 × 1080 px**
* Minimum file size: **1000 KB**
* Maximum images per request: **30** (contact your account manager to raise this limit)
* Maximum total request size: **200 MB**

{% hint style="info" %}
For inspections with more than 16 images, wait at least one minute between submissions. Batch processing is recommended over real-time per-photo processing.
{% endhint %}

#### 2. Submit the images

```bash
curl -X POST https://alto.tchek.fr/apiV1/damage/vehicle \
  -H "X-API-Key: <your_access_token>" \
  -H "Content-Type: application/json" \
  -d '{
    "urls": [
      "https://your-storage.example.com/front-driver.jpg",
      "https://your-storage.example.com/rear-passenger.jpg",
      "https://your-storage.example.com/driver-side.jpg"
    ]
  }'
```

The estimated processing time is around **20 seconds** and may vary depending on the number of images and network conditions.

#### 3. Receive the results

Results are returned over a webhook to the URL you configure, or can be consulted and downloaded from the Hub.

The response contains a `partsCondition` array — the recommended object for reading inspection results. It lists each damaged part with its condition, repair action, cost, and the individual damages found on it (each with bounding box coordinates per image).

```json
{
  "tchekId": "hv28V4IpNt",
  "dataAPI": {
    "status": 200,
    "data": {
      "damageNumber": 4,
      "reportUrl": "https://webapp.tchek.fr/en/report?token=T64F6F7",
      "partsCondition": [
        {
          "code": "PRCAR",
          "partType": "carbody",
          "severityLevel": 3,
          "cost": 220,
          "damages": [
            {
              "id": "dmg_001",
              "type": "scratch",
              "severityLevel": 3,
              "rois": [
                {
                  "imageId": "img_03",
                  "centerX": 0.447,
                  "centerY": 0.764,
                  "width": 0.025,
                  "height": 0.032
                }
              ]
            }
          ]
        }
      ]
    }
  }
}
```

For the full output reference, see [How to read JSON result.](https://tchek.gitbook.io/documentation/api-endpoints/vehicle-inspection/car-body-damage-detection/how-to-read-json-result.md)

***

### Requirements summary

| Parameter                  | Requirement                                              |
| -------------------------- | -------------------------------------------------------- |
| Image formats              | `.jpg`, `.jpeg`, `.png`                                  |
| Minimum resolution         | 1920 × 1080 px                                           |
| Minimum file size          | 1 000 KB                                                 |
| Maximum images per request | 30 (extendable)                                          |
| Maximum request size       | 200 MB                                                   |
| Rate limiting              | No hard limit — short delay recommended between requests |
| Estimated processing time  | \~15 seconds per inspection                              |
| Result delivery            | Webhook or Hub download                                  |

***

### What's new — Alto AI 5.0

Released May 2026.&#x20;

**Improved detection accuracy**

* +3 points in precision (fewer false positives)
* +2 points in recall (fewer missed damages)
* More accurate damage sizing

**3D-based damage grouping** Alto AI 5.0 projects each detection onto a 3D reconstruction of the vehicle built from the submitted photos. When the same physical damage is detected in multiple images, it is automatically grouped into a single entry in the JSON output — instead of producing one damage object per image.

The result: `damageNumber` reflects the number of distinct physical damages on the vehicle (not the number of raw per-image detections), and each damage in `partsCondition` may now contain multiple ROIs — one per image where it was detected.

**Impact on existing integrations**

{% hint style="warning" %}
If damage grouping is enabled for your company, and your integration reads `partsCondition[].damages[].rois`, the `rois` array can now contain more than one item. Code that assumes `rois.length === 1` or accesses `rois[0]` directly must be updated to iterate over all items.

The legacy `data.damages` object is unchanged.
{% endhint %}

See the migration guide for before/after JSON examples and an integration checklist.

**New review interface (end of summer 2026)** A redesigned Fast Track damage review interface is launching this summer, built around grouped damages. Reviewers will see one card per physical defect — with all photos of that damage visible side by side — rather than one card per detection. See Fast Track 2026 — overview.

***

### Next steps
