> ## Documentation Index
> Fetch the complete documentation index at: https://growi.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Video analysis

> Send a video of up to 3 minutes and get labels, a transcript, measures and frame images back, with a notification when it's done.

Send a video to the API and Growi analyzes it in the background. You get an id and an
estimated finish time right away. When the analysis is done, you're notified by email,
Slack or Discord, your organization's webhooks get an event, and the API serves the
result.

## How it works

**1. Submit the video**

`POST /video_analyses` with the file. Growi answers `202` with the analysis `id`, its
`status` (`queued`) and an estimated finish time.

**2. Growi analyzes it**

The analysis moves from `queued` to `processing`, then to `ready` or `failed`. Poll it
or check the [status overview](https://growi.mintlify.site/api-reference/endpoint/video-analyses/analysis-status.md) any
time. Reads don't count toward your rate limits.

**3. You're notified**

The user who created the API key hears about it on the channels they chose (email, Slack
or Discord), and every webhook URL of your organization gets `video_analysis.completed` or
`video_analysis.failed`.

**4. Read the result**

`GET /video_analyses/{id}` returns the labels, transcript, measures, quality and frame
images.

## Before you start

You need a **full-access API key created by a user**. Create one under
**Settings → Developer → API keys** (see [authentication](https://growi.mintlify.site/api-reference/authentication.md)).

* Viewer keys, older keys that aren't tied to a user, and keys whose user was deleted get
  `403` on every video analysis endpoint.
* An analysis is attributed to the user who created the key. That user gets its
  notifications.
* Every full-access key of your organization can read all of its analyses, whoever
  submitted them. Any other id is a `404`.
* Analyses belong to the key's organization. `organization_id` doesn't apply to these
  endpoints.

## Submit a video

Send the file as `multipart/form-data`, in a field named `video`:

```bash theme={"dark"}
curl -X POST https://api.growi.io/api/public/v1/video_analyses \
  -H "Authorization: Bearer growi-sk-YOUR-API-KEY" \
  -H "Idempotency-Key: spring-04" \
  -F "video=@spring-04.mp4" \
  -F "external_id=spring-04"
```

```json 202 Accepted theme={"dark"}
{
  "data": {
    "id": "4f9c2a1e-8b7d-4c3a-9e2f-1a2b3c4d5e6f",
    "status": "queued",
    "eta_seconds": 312,
    "eta_at": "2026-11-20T18:32:12Z"
  }
}
```

| Field | Where | Required | Meaning |
| - | - | - | - |
| `video` | Form field | Yes | The MP4 or MOV file |
| `notify` | Form field | No | Who to notify when it finishes, as JSON: `{"channels": ["email", "slack", "discord"]}`. Leave it out to follow your [notification settings](#notifications) |
| `external_id` | Form field | No | Your own reference, up to 255 characters. Returned with the analysis and in its webhook events |
| `Idempotency-Key` | Header | No | Up to 255 characters. Makes retries safe. See [retries and idempotency](#retries-and-idempotency) |

`notify` can also be sent as form fields: `-F "notify[channels][]=email" -F "notify[channels][]=slack"`.

## Limits

| Limit | Value | Over it |
| - | - | - |
| Format | MP4 or MOV | `415 unsupported_video` |
| File size | 200 MB | `413 video_too_large` |
| Length | 3 minutes | `422 video_too_long` |
| Readable length | Growi must read the duration from the file | `422 video_duration_unreadable` |
| Submissions per user | 20 an hour | `429`, `limit: "user_hourly"` |
| Unfinished analyses per user | 5 at a time (`queued` or `processing`) | `429`, `limit: "user_in_flight"` |
| Submissions per organization | 100 a day | `429`, `limit: "organization_daily"` |

* Growi measures the length from the file itself; there's no length field to send. If it
  can't read the duration, the video is refused with `video_duration_unreadable`. This
  happens most often with fragmented MP4s. Export the video again as a standard MP4 or MOV
  and retry.
* A submission-limit `429` has `code: "rate_limited"`, a `limit` field naming the limit, and
  a `Retry-After` header with the number of seconds to wait before retrying.
* `POST /video_analyses` also counts toward the API's [rate limits](https://growi.mintlify.site/api-reference/rate-limits.md)
  (2 seconds between calls and an hourly cap). The `GET` endpoints under `/video_analyses`,
  frame images included, don't count toward them.

## Retries and idempotency

Send an `Idempotency-Key` header with every submission, so a retry after a timeout or a
dropped connection can't start a second analysis.

* **Same key again:** you get `202` with the original analysis's `id` and its current
  `status`, plus the header `Idempotent-Replayed: true`. Growi doesn't store or analyze the
  file again.
  * While the analysis is unfinished, the repeat has the same live `status` and estimate
    (`eta_seconds`, `eta_at`) as
    [`GET /video_analyses/{id}`](https://growi.mintlify.site/api-reference/endpoint/video-analyses/get-video-analysis). The estimate is
    `null` only when there's no estimate right now, or when Growi hasn't yet confirmed that
    the analysis started.
  * After the analysis has finished, a repeat returns `ready`, `failed` or `expired`, with no
    estimate.
* **The first request is still uploading:** you get `409 idempotency_in_progress`. Retry in
  a moment.
* **Keys are per user:** a key is scoped to the user who created the API key, in your
  organization. Two users can send the same key without clashing.
* **Only the key is compared.** A repeat returns the original analysis even if it carries a
  different file, so use a new key for each new video.
* **Failures that keep nothing:** `502 upload_failed`, `502 submission_rejected` and
  `503 analysis_unavailable` leave no analysis behind, so you can retry with the same key.
  `503` comes with `Retry-After`.

> [!NOTE]
>
> If a submission's upload is cut off and never completes, its key keeps answering `409` until
> Growi gives up on it. After that, the key returns that analysis as `failed`, with
> `error_code: "submission_interrupted"`. This failure sends no email, Slack or Discord
> notification and no `video_analysis.failed` webhook. Send the video again with a new key.

Rarely, Growi can't confirm right away that the analysis started. You still get `202`,
with `eta_seconds` and `eta_at` set to `null`, and Growi keeps trying in the background. If
a later attempt is rejected, or the analysis still can't be started after a day, it fails with
`error_code: "submission_failed"` and you're notified as usual.

## Statuses

| Status | Meaning |
| - | - |
| `queued` | Accepted and waiting to start |
| `processing` | Being analyzed |
| `ready` | Done. `result` holds the analysis |
| `failed` | Couldn't be completed. `error_code` says why |
| `expired` | Done, and its frame images are past their 30 days. The rest of the result stays |

`queued` and `processing` are unfinished, and `ready` and `failed` are final. An analysis
becomes `expired` 30 days after it finished (`frames_expire_at`). Analyses and their results
are kept after that.

`error_code` is set only on failed analyses. Values include:

| `error_code` | Meaning |
| - | - |
| `submission_interrupted` | The upload never completed |
| `submission_failed` | The submission was rejected later, or couldn't be started within a day |
| `blocked` | The analysis was blocked |
| `analysis_failed` | The analysis failed, with no more specific reason |

Other short codes can appear, such as `video_too_long`. Treat a code you don't recognize as a
general failure.

## Track progress

* **One analysis:** [`GET /video_analyses/{id}`](https://growi.mintlify.site/api-reference/endpoint/video-analyses/get-video-analysis)
  returns its `status`, its `stages` (each with a `stage` name, a `state`, `started_at` and
  `finished_at`), and its estimated finish time while it's unfinished.
* **All analyses:** [`GET /video_analyses`](https://growi.mintlify.site/api-reference/endpoint/video-analyses/list-video-analyses)
  lists your organization's analyses, newest first. Filter with `status` and page with `page`
  and `per_page` (up to 100).
* **Overview:** [`GET /video_analyses/status`](https://growi.mintlify.site/api-reference/endpoint/video-analyses/analysis-status)
  counts what's `queued` and `processing` and what finished or failed in the last 24 hours. It
  also returns the estimate for your oldest unfinished analysis whose submission has been
  confirmed (`oldest_unfinished`). It's `null` when no unfinished analysis has a confirmed
  submission, even if `counts.queued` isn't zero. Submissions Growi hasn't confirmed yet aren't
  included. `new_submission` is the estimate a
  new video of `length_s` seconds would get now (40 seconds by default).

The estimate is `eta_seconds` (seconds from now) and `eta_at` (the same moment, in UTC). It's
an estimate, not a promise. It's only present while an analysis is `queued` or `processing`,
and either field can be `null` when there's no estimate.

> [!TIP]
>
> Polling is free of rate limits, but you don't need it. Wait for the notification or the
> webhook event, or check back around `eta_at`.

## Results

Once `status` is `ready`, `GET /video_analyses/{id}` returns `result`:

| Field | Meaning |
| - | - |
| `labels` | Labels for the video. See [labels](#labels) |
| `transcript` | What's said in the video. See [transcript](#transcript) |
| `measures` | Timing and pacing, measured from the file. See [measures](#measures) |
| `quality` | Picture and sound, measured from the file. See [quality](#quality) |
| `frames` | Scene shots and key frames: `n`, `kind` (`scene` or `key`), `t_s` (seconds into the video), `width`, `height` and `url` |
| `frames_expired` | `true` once the frame images have expired |

`result` is `null` until the analysis is ready. `labels`, `transcript`, `measures` and
`quality` are JSON objects, and any of them can be `null`. Inside them, a field that couldn't
be set can be `null` or left out, so read every field as optional.

Only the fields below are returned. Growi's own processing details, such as record ids,
versions, timings and costs, aren't part of the result.

### Example

A ready analysis of a 33-second skincare review. `stages` is left out here, and the labels,
transcript, quality values and frames are cut short:

```json 200 OK theme={"dark"}
{
  "data": {
    "id": "4f9c2a1e-8b7d-4c3a-9e2f-1a2b3c4d5e6f",
    "status": "ready",
    "external_id": "spring-04",
    "video_length_s": 33.09,
    "submitted_at": "2026-11-20T18:27:00Z",
    "completed_at": "2026-11-20T18:31:40Z",
    "frames_expire_at": "2026-12-20T18:31:40Z",
    "error_code": null,
    "result": {
      "labels": {
        "status": "ok",
        "schema": 4,
        "missing": [],
        "attrs": {
          "hook": "Woman washing face at night in bathroom",
          "hook_type": "problem",
          "hook_text": "Nothing ruins my nighttime routine faster",
          "format": "review",
          "niche": "skincare_haircare",
          "tone": ["relatable", "educational"],
          "style": ["casual", "testimony", "clean girl"],
          "tags": ["skincare", "cleanser", "review", "nighttime", "routine", "makeup"],
          "products": ["Lumen Skin Daily Glow Exfoliating Cleanser"],
          "brands": ["Lumen Skin"],
          "claims": ["Gently exfoliates while cleansing", "Designed for sensitive skin"],
          "moments": [
            { "t": 0.2, "what": "washing face at night" },
            { "t": 9.88, "what": "cleanser product shown" }
          ],
          "is_marketing": true,
          "cta": "none",
          "editing_style": "jump_cuts",
          "caption_style": "burned_captions",
          "product_first_seen_s": 9.88,
          "summary": "Creator reviews an exfoliating cleanser for face washing",
          "unsure": ["production", "light_source", "video_quality"]
        }
      },
      "transcript": {
        "status": "ok",
        "language": "en",
        "text": "Nothing ruins my nighttime routine faster than having to wash my face twice. I've tried cleansers that look like they removed everything until I grabbed a towel.",
        "words": 121,
        "segments": [
          {
            "start_s": 0.0,
            "end_s": 3.94,
            "text": "Nothing ruins my nighttime routine faster than having to wash my face twice."
          },
          {
            "start_s": 3.94,
            "end_s": 8.24,
            "text": "I've tried cleansers that look like they removed everything until I grabbed a towel."
          }
        ]
      },
      "measures": {
        "status": "ok",
        "duration_s": 33.09,
        "aspect": "vertical",
        "has_audio": true,
        "has_speech": true,
        "word_count": 121,
        "words_per_min": 223,
        "speech_ratio": 0.98,
        "silence_ratio": 0.0,
        "sound_bed_ratio": 0.02,
        "first_word_s": 0.0,
        "first_cut_s": 4.33,
        "hook_scene_s": 4.33,
        "scene_count": 19,
        "cuts_per_10s": 5.44,
        "loudness_lufs": -14.6,
        "spoken_hook": "Nothing ruins my nighttime routine faster than having to wash my face twice."
      },
      "quality": {
        "status": "ok",
        "source_width": 720,
        "source_height": 1280,
        "source_fps": 30.0,
        "source_video_bitrate_bps": 1750143.0,
        "source_audio_bitrate_bps": 57105.0,
        "dark_video": false,
        "luma_median": 121.02,
        "contrast_median": 59.98,
        "saturation_median": 0.375,
        "colorfulness_median": 46.96,
        "sharpness_median": 565.97,
        "blurry_share": 0.0,
        "motion_median_px": 0.756,
        "steady_share": 0.266,
        "hook_luma": 131.13,
        "hook_sharpness": 441.2,
        "audio_peak_dbfs": -2.89,
        "audio_noise_floor_dbfs": -40.11,
        "audio_speech_to_noise_db": 3.14,
        "audio_clipping_share": 0.0
      },
      "frames": [
        {
          "n": 0,
          "kind": "key",
          "t_s": 0.2,
          "width": 216,
          "height": 384,
          "url": "https://api.growi.io/api/public/v1/video_analyses/4f9c2a1e-8b7d-4c3a-9e2f-1a2b3c4d5e6f/frames/0"
        },
        {
          "n": 1,
          "kind": "scene",
          "t_s": 1.08,
          "width": 216,
          "height": 384,
          "url": "https://api.growi.io/api/public/v1/video_analyses/4f9c2a1e-8b7d-4c3a-9e2f-1a2b3c4d5e6f/frames/1"
        }
      ],
      "frames_expired": false
    }
  }
}
```

### Labels

| Field | Meaning |
| - | - |
| `status` | `ok`, or `partial` when some labels couldn't be set |
| `schema` | Version of the label set, a number |
| `missing` | Labels that couldn't be set |
| `attrs` | The labels themselves, keyed by name |

`attrs` holds every label Growi sets: the hook (`hook`, `hook_type`, `hook_text`,
`hook_template`), the format, niche, tone, style and tags, the products, brands and claims,
the story beats, key `moments` (each a time `t` in seconds and `what` happens), the offer and
call to action, the setting, lighting, editing and caption style, a `summary` and
`description`, and `unsure`, the labels Growi isn't confident about. A label is a string, a
number, a boolean, a list or, like `moments`, a list of objects.

New labels can appear in `attrs`. Ignore names you don't use, and treat any label as
possibly absent.

### Transcript

| Field | Meaning |
| - | - |
| `status` | `ok` when the speech was transcribed |
| `language` | Language of the speech, such as `en`. Can be `null` |
| `text` | The whole transcript. Can be `null` |
| `words` | Number of words. Can be `null` |
| `segments` | The transcript in timed parts, each with `start_s` and `end_s` (seconds into the video) and its `text` |

### Measures

The values sit directly under `result.measures`, for example `result.measures.duration_s`.

| Field | Meaning |
| - | - |
| `status` | `ok`, or `failed` when the video couldn't be measured. A failed block has no other values |
| `duration_s` | Length, in seconds |
| `aspect` | `vertical`, `square` or `horizontal` |
| `has_audio` | Whether the file has a sound track |
| `has_speech` | Whether the video has speech |
| `word_count` | Number of spoken words |
| `words_per_min` | Spoken words per minute |
| `speech_ratio` | Share of the video with speech, from 0 to 1 |
| `silence_ratio` | Share of the video that's silent, from 0 to 1 |
| `sound_bed_ratio` | Share of the video with sound that isn't speech (music, effects or ambience), from 0 to 1 |
| `first_word_s` | When the first word is spoken, in seconds |
| `first_cut_s` | When the first cut happens, in seconds. `null` with no cut |
| `hook_scene_s` | How long the opening shot lasts, in seconds |
| `scene_count` | Number of scenes |
| `cuts_per_10s` | Cuts per 10 seconds |
| `loudness_lufs` | Integrated loudness, in LUFS |
| `spoken_hook` | The opening words: what's said in about the first 3 seconds |

With no speech, `has_speech` is `false`, `first_word_s` is `null`, `word_count`,
`words_per_min` and `speech_ratio` are `0`, and `spoken_hook` is empty. When a video has
sound but no transcript, the speech values are `null`.

### Quality

The values sit directly under `result.quality`, for example `result.quality.luma_median`. They
are measured on frames sampled across the video. Read them as signals to compare videos by,
not as a quality score.

| Field | Meaning |
| - | - |
| `status` | `ok`, or `failed` when the video couldn't be measured. A failed block has no other values |
| `source_width`, `source_height` | Size of the uploaded video, in pixels |
| `source_fps` | Frame rate of the uploaded video |
| `source_video_bitrate_bps`, `source_audio_bitrate_bps` | Video and audio bitrates, in bits per second |
| `dark_video` | `true` when the picture is dark overall |
| `luma_median`, `luma_p10`, `luma_p90` | Brightness, from 0 to 255: median, 10th and 90th percentile |
| `contrast_median` | Contrast |
| `saturation_median` | Color saturation, from 0 to 1 |
| `colorfulness_median` | How colorful the picture is |
| `warmth_median` | Color warmth. Higher is warmer |
| `lab_a_median`, `lab_b_median` | Color balance in CIELAB: `a` from green to red, `b` from blue to yellow |
| `shadow_share_median`, `highlight_share_median` | Share of the picture in deep shadow or bright highlight, from 0 to 1 |
| `sharpness_median`, `sharpness_p10`, `sharpness_p90` | Sharpness. Higher is sharper |
| `blurry_share` | Share of sampled frames that are blurry, from 0 to 1 |
| `noise_sigma_median`, `noise_sigma_p10`, `noise_sigma_p90` | Picture noise. Higher is noisier |
| `motion_median_px`, `motion_p90_px` | Camera movement between frames: median and 90th percentile |
| `jitter_median_px` | Camera shake |
| `steady_share` | Share of the video where the camera is steady, from 0 to 1 |
| `motion_valid_share` | Share of the video where motion could be measured, from 0 to 1 |
| `hook_luma`, `hook_contrast`, `hook_saturation`, `hook_colorfulness`, `hook_warmth`, `hook_lab_a`, `hook_lab_b`, `hook_shadow_share`, `hook_highlight_share`, `hook_sharpness`, `hook_noise_sigma` | The same picture values for the first second of the video |
| `audio_peak_dbfs` | Loudest peak, in dBFS |
| `audio_noise_floor_dbfs` | Background noise level, in dBFS |
| `audio_speech_to_noise_db` | How far speech stands above the background noise, in dB |
| `audio_clipping_share` | Share of the sound that's clipped, from 0 to 1 |

A value that can't be measured is `null`, such as the audio values of a video with no sound
track.

### Frame images

Each frame's `url` points to
[`GET /video_analyses/{id}/frames/{n}`](https://growi.mintlify.site/api-reference/endpoint/video-analyses/get-frame).
It isn't a public link: fetch it with your API key, like any other call:

```bash theme={"dark"}
curl https://api.growi.io/api/public/v1/video_analyses/4f9c2a1e-8b7d-4c3a-9e2f-1a2b3c4d5e6f/frames/0 \
  -H "Authorization: Bearer growi-sk-YOUR-API-KEY" \
  -o frame-0.jpg
```

The response is the image itself. Read `Content-Type` for its type, usually `image/jpeg`. It's
sent with `Cache-Control: private`. Frame images are kept for 30 days after the analysis finished
(`frames_expire_at`). After that:

* the analysis reads `status: "expired"`, `result.frames` is empty and
  `result.frames_expired` is `true`;
* a frame URL answers `410 frames_expired`, for any frame number, whether or not that frame
  existed;
* the rest of the result stays readable.

`n` must be a frame number written as plain digits, such as `0` or `7`. Anything else, such
as `-1`, `abc` or `0x1`, answers `404 not_found`, even on an expired analysis. A frame number
the result doesn't have is also `404 not_found` while the images are kept.

If a frame can't be read for a moment, its URL answers `502 frame_unavailable`; retry it.

Save the frames you want to keep before they expire.

## Notifications

Once its upload completes, Growi notifies the **user who created the API key** when an
analysis finishes or fails.

| Channel | Where it goes |
| - | - |
| Email | That user's email address only |
| Slack | Your organization's Slack report channel, set up under **Settings → Webhooks** |
| Discord | Your organization's Discord report channel, set up under **Settings → Webhooks** |

If your organization has no Slack or Discord report channel, nothing is posted there. There
are no SMS notifications for video analysis.

### Choose channels in Settings

Each user picks their own channels under **Settings → Notifications**, in the
**AI media analysis** group:

![Settings, Notifications section in the Growi dashboard, with the AI media analysis group](https://mintcdn.com/growi/QqN8Kdn5JXM09KDm/images/notifications-ai-media-analysis.png?fit=max\&auto=format\&n=QqN8Kdn5JXM09KDm\&q=85\&s=d8c114af715a0af43a1729b785393362)

The group has two events, **Analysis completed** and **Analysis failed**. Each has its own
email setting (**Off**, **As it happens** or **In a digest**, a daily email around 9 AM ET)
and its own **Slack** and **Discord** switches:

![The AI media analysis notification group, with email, Slack and Discord settings for Analysis completed and Analysis failed](https://mintcdn.com/growi/QqN8Kdn5JXM09KDm/images/notifications-ai-media-analysis-crop.png?fit=max\&auto=format\&n=QqN8Kdn5JXM09KDm\&q=85\&s=9363f2a87e8a46252f5eaa20ff02c855)

By default, email is sent as it happens and Slack and Discord are off. Turn a switch on to
also post that event to your organization's channel:

![The AI media analysis notification group with Slack turned on for an event](https://mintcdn.com/growi/QqN8Kdn5JXM09KDm/images/notifications-ai-media-analysis-slack-on.png?fit=max\&auto=format\&n=QqN8Kdn5JXM09KDm\&q=85\&s=7fa038e601993358265f09d520c4b6d8)

These settings are personal: they apply to the analyses submitted with keys you created.

### Choose channels per video

To pick channels for one analysis, send `notify` with the submission:

```bash theme={"dark"}
-F 'notify={"channels": ["slack"]}'
```

`notify` replaces the settings for that analysis: only the channels you name are used, and a
named `email` is sent right away, not held for a digest. `channels` must list at least one of
`email`, `slack` and `discord`. Anything else, `sms` and `webhook` included, gets
`422 invalid_notify`.

Webhooks aren't a notification channel you choose. Your organization's webhooks always get
the events, whatever `notify` or the settings say. The one exception is an upload that never
completes (`submission_interrupted`, above): it sends no event.

## Webhook events

Every active webhook URL of your organization (**Settings → Webhooks**) receives:

| Event | Sent when |
| - | - |
| `video_analysis.completed` | The analysis is ready |
| `video_analysis.failed` | The analysis failed |

```json theme={"dark"}
{
  "event": "video_analysis.completed",
  "idempotency_key": "video_analysis.completed:4f9c2a1e-8b7d-4c3a-9e2f-1a2b3c4d5e6f",
  "occurred_at": "2026-11-20T18:31:40Z",
  "video_analysis_id": "4f9c2a1e-8b7d-4c3a-9e2f-1a2b3c4d5e6f",
  "external_id": "spring-04",
  "organization_id": 789,
  "organization_slug": "acme",
  "user_id": 42,
  "status": "ready"
}
```

The payload holds ids and the status only. Read the result with
`GET /video_analyses/{video_analysis_id}`. See the
[payload reference](https://growi.mintlify.site/webhooks/payloads.md#video-analysis-events) for each field.

Delivery works like the other Growi webhooks: a JSON `POST` to your webhook URL, retried up
to 3 times on a non-2xx response. Use an HTTPS URL for encrypted delivery. When your
organization has an active `growi-sk-` API key, the request carries
`Authorization: Bearer <your newest active growi-sk key>`; with none, the header is left out.
Delivery is at-least-once, so deduplicate on `idempotency_key`.

## Errors

Errors are JSON with an `error` message and, on these endpoints, a `code`:

```json theme={"dark"}
{
  "error": "The video is longer than 3 minutes",
  "code": "video_too_long"
}
```

| Status | `code` | Meaning |
| - | - | - |
| `401` | | Missing or invalid API key |
| `403` | `forbidden` | Not a full-access key created by a user. A viewer key's `POST` gets the [read-only error](https://growi.mintlify.site/api-reference/authentication.md#authentication-errors), without a `code` |
| `404` | `not_found` | No such analysis in your organization, no such frame, or a frame number that isn't plain digits |
| `409` | `idempotency_in_progress` | A request with this `Idempotency-Key` is still uploading |
| `410` | `frames_expired` | The frame images have expired, for any frame number |
| `413` | `video_too_large` | The video is over 200 MB |
| `415` | `unsupported_video` | Not an MP4 or MOV video |
| `422` | `video_required` | No file in the `video` field |
| `422` | `video_too_long` | The video is longer than 3 minutes |
| `422` | `video_duration_unreadable` | The video's duration can't be read from the file |
| `422` | `invalid_notify` | `notify` isn't valid JSON or names an unknown channel |
| `422` | `invalid_external_id`, `invalid_idempotency_key` | Over 255 characters |
| `422` | `invalid_status` | Unknown `status` filter on the list |
| `422` | `invalid_length_s` | `length_s` isn't above 0 and at most 180 |
| `429` | `rate_limited` | A submission limit. `limit` says which. Wait for `Retry-After` |
| `429` | | The API's [rate limit](https://growi.mintlify.site/api-reference/rate-limits.md). Wait for `Retry-After` |
| `502` | `upload_failed`, `submission_rejected` | The video couldn't be stored or the analysis couldn't be started. Nothing was kept; retry |
| `502` | `frame_unavailable` | A frame image couldn't be read right now. Retry |
| `503` | `analysis_unavailable` | Temporarily unavailable. Nothing was kept; retry after `Retry-After` |

## Related

* [Submit a video](https://growi.mintlify.site/api-reference/endpoint/video-analyses/submit-video.md)
* [Get video analysis](https://growi.mintlify.site/api-reference/endpoint/video-analyses/get-video-analysis.md)
* [Webhook payload reference](https://growi.mintlify.site/webhooks/payloads.md#video-analysis-events)


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.