---
title: "List Models"
method: GET
path: "/media/models"
tags: ["media"]
---

# List Models

`GET /media/models`

## Request

- Base URL: `https://api.moda.app/v1`
- URL: `https://api.moda.app/v1/media/models`
- Auth: HTTP bearer

The model registry the ``model`` parameters validate against.

## Headers

- `Moda-Version` '2026-04-12' | '2026-05-01'

## Response `200`

Successful Response

- MediaModelsResponse: The model registry the ``model`` parameters validate against. The arrays serialize the same registries the generate verbs resolve against, so a capability stated here is a capability the request validator accepts — nothing is transcribed by hand.
  - `image_transforms` PublicImageTransformModel[], required: Image transforms served by /v1/media/vectorize and /v1/media/precise-edit (modes: quality).
    - `id` string, required
    - `label` string, required
    - `description` string, required
    - `operation` 'vectorize' | 'precise_edit', required
    - `output_format` string, required
    - `modes` string[], required
    - `max_input_bytes` integer, required
    - `accepted_input_mimes` string[], required
  - `image_models` object[], required: Image model capability descriptors, for generate-image / edit-image.
  - `video_models` PublicVideoModelDescriptor[], required: Video model capability descriptors, for generate-video: per-mode aspect/resolution/duration envelopes, audio and seed support, input-image and reference limits, the validated model_params controls, and how each mode's cost is metered. Exact credit amounts are computed from the resolved request by the usage pipeline at the team's credit rate — the billing block reports the basis and the knobs that move it, not a flat price.
    - `id` string, required: The registry id the generate-video 'model' parameter validates against.
    - `label` string, required
    - `description` string, required: What the model is good at, relative to its registry siblings.
    - `supports_generate_audio` boolean, required: Whether the model can generate native audio. generate_audio=true on a model where this is false is rejected before billing.
    - `generate_audio_default` boolean, required: The effective audio setting when generate_audio is omitted. Where billing.audio_priced_separately is true, a default of true means the DEFAULT render bills the audio rate — pass generate_audio=false for the cheaper silent rate.
    - `generate_audio_controllable` boolean, required: Whether generate_audio can be turned off. False means audio is intrinsic to the model: generate_audio=false is accepted, reported as an adjustment, and produces audio anyway. Steer such a model's audio through the prompt instead.
    - `supports_seed` boolean, required: Whether the request may pin a seed; an unsupported seed is rejected.
    - `max_prompt_chars` integer, nullable: The provider's documented ceiling on prompt length, in characters. A longer prompt is rejected before any input is resolved or billed, so read this before composing one. Null means no ceiling has been established for this model — not that it has none.
    - `max_prompt_bytes` integer, nullable: The provider's documented UTF-8 byte ceiling on prompt length. Null means no byte ceiling has been established, not that the model has none.
    - `modes` PublicVideoModelModes, required: The modes a model supports; an absent mode is unsupported. Supplying start_image selects image_to_video; reference_images or reference_videos select reference_to_video, and reference_audios select it too when they arrive beside one of those. reference_audios ALONE — with or without a start_image, which is the opening frame — selects audio_to_video, where the clip is generated timed to the track and its length is the track's own. extend_video selects video_extend and lipsync_video selects video_lipsync; each takes one source clip, neither may be combined with the other or with any of the inputs above, and lipsync_video additionally REQUIRES one reference_audios track — the speech the mouth is re-cut to. A bare prompt is text_to_video.
      - `text_to_video` PublicVideoModeCapability: One generation mode's real capability envelope for one model.
        - `aspect_ratios` string[], required: Aspect ratios the mode accepts ('auto' = the provider chooses the framing). Empty means the mode has no aspect control at all — the endpoint decides (an image route frames from its input still, a source_video mode from the source clip, a text route from the endpoint's own default), and a requested ratio is dropped and reported.
        - `default_aspect_ratio` string, nullable, required: The framing used when aspect_ratio is omitted; null when the mode has no aspect control.
        - `end_image_aspect_ratios` string[], nullable: The both-frames route's aspect ratios when they differ from the single-frame route.
        - `end_image_default_aspect_ratio` string, nullable: The both-frames route's default aspect ratio when that route has its own axis.
        - `resolutions` string[], required: Supported resolution tiers (for example 720p, 2k, or 4k). Actual pixel dimensions may depend on the selected aspect ratio or input image. Empty means the mode has no resolution control and a requested resolution is dropped and reported. What comes back instead: where the mode declares a source_video, the source clip's own frame size, which is also what selects the rate tier; otherwise read fixed_output_resolution, where a size is what the endpoint ALWAYS returns and only a null means the output size is genuinely not something we can state.
        - `default_resolution` string, nullable, required: The resolution used when resolution is omitted; null when the mode has no resolution control.
        - `fixed_output_resolution` string, nullable: The size this mode ALWAYS returns, where it has no resolution control to ask with. Null means the output size is not something we can state — not that it varies with the request. Read this rather than resolutions when resolutions is empty.
        - `duration_seconds` PublicVideoDuration, required: One mode's clip-length envelope, in whole seconds.
          - `min_seconds` integer, required: Shortest clip this mode can generate, in whole seconds. On a mode whose source_video reports output_includes_source, this is the length of the ADDED segment and the delivered clip is longer than it by the source's own running time — read source_video before budgeting from this number.
          - `max_seconds` integer, required: Longest clip this mode can generate, in whole seconds. On a mode whose source_video reports output_includes_source, this bounds the ADDED segment rather than the delivered clip, and the provider may meter the whole delivered clip or only the added segment; read billing.duration_quantity.
          - `allowed_seconds` integer[], nullable: The exact legal clip lengths, for a model that takes only fixed lengths (e.g. Veo's 4/6/8). null means every whole second in [min_seconds, max_seconds] is legal. Out-of-envelope asks snap to the nearest supported value and the adjustment is reported in the response.
          - `default` union, required: What runs when duration_seconds is omitted. A numeric value is a fixed default; 'auto' means omission itself lets the provider pick the clip length.
            - integer
            - 'auto'
          - `supports_auto` boolean, required: Whether the model can be asked to pick the clip length by passing duration_seconds="auto". Omitting duration_seconds takes default, which may independently be numeric or 'auto'.
          - `controllable` boolean: Whether duration_seconds is a control on this mode at all. False means the clip length is DERIVED from an input: an audio-driven mode renders to the driving track, and a lip-sync returns the source clip at its own length. Either way every explicit ask is answered with the input's measured length and reported as an adjustment, and the min/max here bound that input rather than a choice. Where this is false, read default and supports_auto as 'nothing to pick', not as 'the provider picks'.
        - `supports_end_image` boolean, required: image_to_video only: whether the request may carry end_image alongside start_image for a first-to-last-frame morph.
        - `end_image_duration_seconds` PublicVideoDuration: One mode's clip-length envelope, in whole seconds.
          - `min_seconds` integer, required: Shortest clip this mode can generate, in whole seconds. On a mode whose source_video reports output_includes_source, this is the length of the ADDED segment and the delivered clip is longer than it by the source's own running time — read source_video before budgeting from this number.
          - `max_seconds` integer, required: Longest clip this mode can generate, in whole seconds. On a mode whose source_video reports output_includes_source, this bounds the ADDED segment rather than the delivered clip, and the provider may meter the whole delivered clip or only the added segment; read billing.duration_quantity.
          - `allowed_seconds` integer[], nullable: The exact legal clip lengths, for a model that takes only fixed lengths (e.g. Veo's 4/6/8). null means every whole second in [min_seconds, max_seconds] is legal. Out-of-envelope asks snap to the nearest supported value and the adjustment is reported in the response.
          - `default` union, required: What runs when duration_seconds is omitted. A numeric value is a fixed default; 'auto' means omission itself lets the provider pick the clip length.
            - integer
            - 'auto'
          - `supports_auto` boolean, required: Whether the model can be asked to pick the clip length by passing duration_seconds="auto". Omitting duration_seconds takes default, which may independently be numeric or 'auto'.
          - `controllable` boolean: Whether duration_seconds is a control on this mode at all. False means the clip length is DERIVED from an input: an audio-driven mode renders to the driving track, and a lip-sync returns the source clip at its own length. Either way every explicit ask is answered with the input's measured length and reported as an adjustment, and the min/max here bound that input rather than a choice. Where this is false, read default and supports_auto as 'nothing to pick', not as 'the provider picks'.
        - `max_reference_images` integer, required: reference_to_video only: maximum reference_images one request may carry. 0 means the mode takes no reference images.
        - `reference_videos` PublicVideoReferenceVideos, required: The reference-VIDEO (video-to-video) envelope, where a mode has one.
          - `max_count` integer, required: Maximum reference clips one request may carry.
          - `min_seconds_each` number, required: Minimum running time per reference clip, in seconds.
          - `max_seconds_each` number, required: Maximum running time per reference clip, in seconds.
          - `max_total_seconds` number, required: Maximum combined running time across all reference clips.
          - `input_duration_billed` boolean, required: Whether the reference clips' own running time is billed on top of the generated clip's.
          - `price_multiplier` number, required: The provider's published factor a reference-video call's whole charge (including any billed input duration) is multiplied by. 1.0 means the provider publishes no factor.
          - `input_duration_price_multiplier` number, required: Factor applied only to billed reference-video duration; 1.0 means no input-only factor.
        - `reference_audios` PublicVideoReferenceAudios, required: The reference-audio envelope, where a mode has one.
          - `max_count` integer, required
          - `min_seconds_each` number, required
          - `max_seconds_each` number, required
          - `max_total_seconds` number, required
          - `requires_visual_reference` boolean, required: Whether at least one reference image or video must accompany reference audio.
          - `accepted_container_types` string[], nullable: Content types accepted for the driving track, where the mode derives the clip's length from it and bills that length. Only containers Moda measures frame by frame qualify; a container that merely declares its own duration is refused. Null where the mode does not bill the track, in which case every supported audio type is accepted.
        - `source_video` PublicVideoSourceVideo: The SOURCE-clip envelope for a mode that operates on an existing video. A source clip is the video being worked on, not one the model looks at for style or motion — see reference_videos for those. Moda measures the clip and refuses one outside this envelope before it is uploaded or persisted, so an out-of-envelope source costs nothing.
          - `min_seconds` number, nullable, required: Shortest source clip the mode accepts, if published.
          - `max_seconds` number, nullable, required: Longest source clip the mode accepts, if published.
          - `max_area_pixels` integer, nullable, required: Largest source frame the mode accepts, in total pixels (width x height). Stated as an area rather than a width and a height, which is how the provider enforces it: a portrait clip is accepted at the same pixel count as a landscape one.
          - `accepted_formats` string[], required: Container and codecs the provider documents for the source clip, and which Moda enforces against the clip's own bytes before uploading it: a container or a video codec outside this list is refused here rather than by the provider. A clip whose codec cannot be read is not refused — unknown is not the same as unsupported. Empty means the provider publishes no restriction and its own validation is the only gate.
          - `input_seconds_priced_separately` boolean, required: Whether every second of the SOURCE clip is billed on top of the returned clip's per-second charge. False means the source costs nothing beyond the mode's main price.
          - `output_includes_source` boolean, required: Whether the returned clip contains the source as well as the new footage. When true, duration_seconds is the length of the ADDED segment and the delivered video is longer than it by the source's own running time. Read billing.duration_quantity to learn whether the provider meters that whole return or only the requested extension.
        - `max_reference_inputs_total` integer, nullable, required: Maximum combined reference image, video, and audio count; null when there is no combined cap.
        - `image_requirements` PublicVideoImageRequirements[]: The provider's documented requirements for the images this mode is handed, one entry per group of roles sharing an envelope (roles never repeat across entries). Empty when the provider publishes none and its own validation is the only gate. Moda checks these before submitting whenever it already measured the property; for an image supplied as an external URL it has measured nothing, so the provider is the only gate.
          - `roles` string[], required: The image roles this envelope covers: 'start', 'end', and/or 'reference'.
          - `accepted_formats` string[], required: Accepted DECODED image formats (e.g. 'JPEG', 'PNG'). Empty means the provider publishes no format restriction. Matched against the decoded bytes, not the file name or Content-Type.
          - `max_bytes` integer, nullable, required: Largest accepted encoded image, in bytes. Applies per image, not to the set.
          - `min_width` integer, nullable, required: Smallest accepted width, in pixels.
          - `min_height` integer, nullable, required: Smallest accepted height, in pixels.
          - `max_pixels` integer, nullable, required: Largest accepted decoded size, in total pixels (width x height). May be a Moda platform ceiling rather than a provider-published one.
          - `min_aspect_ratio` number, nullable, required: Smallest accepted aspect ratio, measured as width divided by height, inclusive.
          - `max_aspect_ratio` number, nullable, required: Largest accepted aspect ratio, measured as width divided by height, inclusive.
        - `generate_audio_controllable` boolean, required: Whether generate_audio can be turned off ON THIS MODE. False means this endpoint has no such control: generate_audio=false is accepted, reported as an adjustment, and audio comes back anyway. The model-level field of the same name says it about every mode at once; this one can be false on a single mode while the model's others are controllable.
        - `billing` PublicVideoModeBilling, required: How this mode's provider cost is metered. No dollar or credit amount appears here, whatever the basis: the charge is computed asynchronously by the usage pipeline from the resolved request at the team's own credit rate, which this document cannot know. So this reports the BASIS and the knobs that move it — including `call`, where the provider quotes one flat price per generation and the clip's running time moves nothing. A flat basis still does not mean a publishable number.
          - `basis` string, required: The quantity the price is quoted in: 'second' bills per second of generated output; 'megapixel_second' bills on frame area x duration, so resolution AND aspect ratio scale the cost, not just clip length; 'call' bills one flat price per generation, so the clip's running time does not move the charge at all — see higher_rate_durations for the clip lengths that carry a different flat price. Always present — a model whose basis is not expressible does not register.
          - `duration_quantity` string, required: The duration multiplied by a per-second basis: measured_output for ordinary generation, measured_input_audio when a driving track determines and meters the clip length, measured_whole_return when an extension bills source plus tail, or requested_extension when only the requested generated tail is metered.
          - `audio_priced_separately` boolean, required: Whether generate_audio=true bills a distinct (higher) rate than a silent render. False means audio is folded into one price.
          - `higher_rate_resolutions` string[], required: Resolutions whose RATE is above this mode's base rate. For a 'megapixel_second' basis every resolution already scales the cost by area, so this lists only extra rate tiers — and a resolution absent from it can still cost more, because the frame is larger. A provider may even meter a larger frame at a lower rate (Seedance 2.0's 4K), which is why this reads the rate rather than which resolutions carry their own price. Where the resolutions list is empty because the output follows a source video, these bands are selected by the SOURCE clip's measured frame rather than by anything the request carries.
          - `input_seconds_priced_separately` boolean, required: Whether every second of a source video adds a per-second charge on top of the returned clip's rate, on its own key. False means the source clip costs nothing beyond the mode's main price.
          - `higher_rate_durations` integer[], required: Clip lengths, in whole seconds, whose RATE is above this mode's base rate. Non-empty only where the provider publishes a separate price per clip length that is not a multiple of a per-second rate (Hailuo 2.3 standard: $0.28 for 6 seconds against $0.56 for 10). Empty means clip length either does not change the rate or scales it linearly through the basis above.
          - `reference_images_priced_separately` boolean, required: Whether each reference image adds a flat charge on top of the per-second rate, billed independently of clip length and resolution. False means reference images cost nothing beyond the mode's main price.
          - `reference_images_included_before_surcharge` integer, required: How many reference images carry no separate input surcharge. Meaningful only when reference_images_priced_separately is true.
      - `image_to_video` PublicVideoModeCapability: One generation mode's real capability envelope for one model.
        - `aspect_ratios` string[], required: Aspect ratios the mode accepts ('auto' = the provider chooses the framing). Empty means the mode has no aspect control at all — the endpoint decides (an image route frames from its input still, a source_video mode from the source clip, a text route from the endpoint's own default), and a requested ratio is dropped and reported.
        - `default_aspect_ratio` string, nullable, required: The framing used when aspect_ratio is omitted; null when the mode has no aspect control.
        - `end_image_aspect_ratios` string[], nullable: The both-frames route's aspect ratios when they differ from the single-frame route.
        - `end_image_default_aspect_ratio` string, nullable: The both-frames route's default aspect ratio when that route has its own axis.
        - `resolutions` string[], required: Supported resolution tiers (for example 720p, 2k, or 4k). Actual pixel dimensions may depend on the selected aspect ratio or input image. Empty means the mode has no resolution control and a requested resolution is dropped and reported. What comes back instead: where the mode declares a source_video, the source clip's own frame size, which is also what selects the rate tier; otherwise read fixed_output_resolution, where a size is what the endpoint ALWAYS returns and only a null means the output size is genuinely not something we can state.
        - `default_resolution` string, nullable, required: The resolution used when resolution is omitted; null when the mode has no resolution control.
        - `fixed_output_resolution` string, nullable: The size this mode ALWAYS returns, where it has no resolution control to ask with. Null means the output size is not something we can state — not that it varies with the request. Read this rather than resolutions when resolutions is empty.
        - `duration_seconds` PublicVideoDuration, required: One mode's clip-length envelope, in whole seconds.
          - `min_seconds` integer, required: Shortest clip this mode can generate, in whole seconds. On a mode whose source_video reports output_includes_source, this is the length of the ADDED segment and the delivered clip is longer than it by the source's own running time — read source_video before budgeting from this number.
          - `max_seconds` integer, required: Longest clip this mode can generate, in whole seconds. On a mode whose source_video reports output_includes_source, this bounds the ADDED segment rather than the delivered clip, and the provider may meter the whole delivered clip or only the added segment; read billing.duration_quantity.
          - `allowed_seconds` integer[], nullable: The exact legal clip lengths, for a model that takes only fixed lengths (e.g. Veo's 4/6/8). null means every whole second in [min_seconds, max_seconds] is legal. Out-of-envelope asks snap to the nearest supported value and the adjustment is reported in the response.
          - `default` union, required: What runs when duration_seconds is omitted. A numeric value is a fixed default; 'auto' means omission itself lets the provider pick the clip length.
            - integer
            - 'auto'
          - `supports_auto` boolean, required: Whether the model can be asked to pick the clip length by passing duration_seconds="auto". Omitting duration_seconds takes default, which may independently be numeric or 'auto'.
          - `controllable` boolean: Whether duration_seconds is a control on this mode at all. False means the clip length is DERIVED from an input: an audio-driven mode renders to the driving track, and a lip-sync returns the source clip at its own length. Either way every explicit ask is answered with the input's measured length and reported as an adjustment, and the min/max here bound that input rather than a choice. Where this is false, read default and supports_auto as 'nothing to pick', not as 'the provider picks'.
        - `supports_end_image` boolean, required: image_to_video only: whether the request may carry end_image alongside start_image for a first-to-last-frame morph.
        - `end_image_duration_seconds` PublicVideoDuration: One mode's clip-length envelope, in whole seconds.
          - `min_seconds` integer, required: Shortest clip this mode can generate, in whole seconds. On a mode whose source_video reports output_includes_source, this is the length of the ADDED segment and the delivered clip is longer than it by the source's own running time — read source_video before budgeting from this number.
          - `max_seconds` integer, required: Longest clip this mode can generate, in whole seconds. On a mode whose source_video reports output_includes_source, this bounds the ADDED segment rather than the delivered clip, and the provider may meter the whole delivered clip or only the added segment; read billing.duration_quantity.
          - `allowed_seconds` integer[], nullable: The exact legal clip lengths, for a model that takes only fixed lengths (e.g. Veo's 4/6/8). null means every whole second in [min_seconds, max_seconds] is legal. Out-of-envelope asks snap to the nearest supported value and the adjustment is reported in the response.
          - `default` union, required: What runs when duration_seconds is omitted. A numeric value is a fixed default; 'auto' means omission itself lets the provider pick the clip length.
            - integer
            - 'auto'
          - `supports_auto` boolean, required: Whether the model can be asked to pick the clip length by passing duration_seconds="auto". Omitting duration_seconds takes default, which may independently be numeric or 'auto'.
          - `controllable` boolean: Whether duration_seconds is a control on this mode at all. False means the clip length is DERIVED from an input: an audio-driven mode renders to the driving track, and a lip-sync returns the source clip at its own length. Either way every explicit ask is answered with the input's measured length and reported as an adjustment, and the min/max here bound that input rather than a choice. Where this is false, read default and supports_auto as 'nothing to pick', not as 'the provider picks'.
        - `max_reference_images` integer, required: reference_to_video only: maximum reference_images one request may carry. 0 means the mode takes no reference images.
        - `reference_videos` PublicVideoReferenceVideos, required: The reference-VIDEO (video-to-video) envelope, where a mode has one.
          - `max_count` integer, required: Maximum reference clips one request may carry.
          - `min_seconds_each` number, required: Minimum running time per reference clip, in seconds.
          - `max_seconds_each` number, required: Maximum running time per reference clip, in seconds.
          - `max_total_seconds` number, required: Maximum combined running time across all reference clips.
          - `input_duration_billed` boolean, required: Whether the reference clips' own running time is billed on top of the generated clip's.
          - `price_multiplier` number, required: The provider's published factor a reference-video call's whole charge (including any billed input duration) is multiplied by. 1.0 means the provider publishes no factor.
          - `input_duration_price_multiplier` number, required: Factor applied only to billed reference-video duration; 1.0 means no input-only factor.
        - `reference_audios` PublicVideoReferenceAudios, required: The reference-audio envelope, where a mode has one.
          - `max_count` integer, required
          - `min_seconds_each` number, required
          - `max_seconds_each` number, required
          - `max_total_seconds` number, required
          - `requires_visual_reference` boolean, required: Whether at least one reference image or video must accompany reference audio.
          - `accepted_container_types` string[], nullable: Content types accepted for the driving track, where the mode derives the clip's length from it and bills that length. Only containers Moda measures frame by frame qualify; a container that merely declares its own duration is refused. Null where the mode does not bill the track, in which case every supported audio type is accepted.
        - `source_video` PublicVideoSourceVideo: The SOURCE-clip envelope for a mode that operates on an existing video. A source clip is the video being worked on, not one the model looks at for style or motion — see reference_videos for those. Moda measures the clip and refuses one outside this envelope before it is uploaded or persisted, so an out-of-envelope source costs nothing.
          - `min_seconds` number, nullable, required: Shortest source clip the mode accepts, if published.
          - `max_seconds` number, nullable, required: Longest source clip the mode accepts, if published.
          - `max_area_pixels` integer, nullable, required: Largest source frame the mode accepts, in total pixels (width x height). Stated as an area rather than a width and a height, which is how the provider enforces it: a portrait clip is accepted at the same pixel count as a landscape one.
          - `accepted_formats` string[], required: Container and codecs the provider documents for the source clip, and which Moda enforces against the clip's own bytes before uploading it: a container or a video codec outside this list is refused here rather than by the provider. A clip whose codec cannot be read is not refused — unknown is not the same as unsupported. Empty means the provider publishes no restriction and its own validation is the only gate.
          - `input_seconds_priced_separately` boolean, required: Whether every second of the SOURCE clip is billed on top of the returned clip's per-second charge. False means the source costs nothing beyond the mode's main price.
          - `output_includes_source` boolean, required: Whether the returned clip contains the source as well as the new footage. When true, duration_seconds is the length of the ADDED segment and the delivered video is longer than it by the source's own running time. Read billing.duration_quantity to learn whether the provider meters that whole return or only the requested extension.
        - `max_reference_inputs_total` integer, nullable, required: Maximum combined reference image, video, and audio count; null when there is no combined cap.
        - `image_requirements` PublicVideoImageRequirements[]: The provider's documented requirements for the images this mode is handed, one entry per group of roles sharing an envelope (roles never repeat across entries). Empty when the provider publishes none and its own validation is the only gate. Moda checks these before submitting whenever it already measured the property; for an image supplied as an external URL it has measured nothing, so the provider is the only gate.
          - `roles` string[], required: The image roles this envelope covers: 'start', 'end', and/or 'reference'.
          - `accepted_formats` string[], required: Accepted DECODED image formats (e.g. 'JPEG', 'PNG'). Empty means the provider publishes no format restriction. Matched against the decoded bytes, not the file name or Content-Type.
          - `max_bytes` integer, nullable, required: Largest accepted encoded image, in bytes. Applies per image, not to the set.
          - `min_width` integer, nullable, required: Smallest accepted width, in pixels.
          - `min_height` integer, nullable, required: Smallest accepted height, in pixels.
          - `max_pixels` integer, nullable, required: Largest accepted decoded size, in total pixels (width x height). May be a Moda platform ceiling rather than a provider-published one.
          - `min_aspect_ratio` number, nullable, required: Smallest accepted aspect ratio, measured as width divided by height, inclusive.
          - `max_aspect_ratio` number, nullable, required: Largest accepted aspect ratio, measured as width divided by height, inclusive.
        - `generate_audio_controllable` boolean, required: Whether generate_audio can be turned off ON THIS MODE. False means this endpoint has no such control: generate_audio=false is accepted, reported as an adjustment, and audio comes back anyway. The model-level field of the same name says it about every mode at once; this one can be false on a single mode while the model's others are controllable.
        - `billing` PublicVideoModeBilling, required: How this mode's provider cost is metered. No dollar or credit amount appears here, whatever the basis: the charge is computed asynchronously by the usage pipeline from the resolved request at the team's own credit rate, which this document cannot know. So this reports the BASIS and the knobs that move it — including `call`, where the provider quotes one flat price per generation and the clip's running time moves nothing. A flat basis still does not mean a publishable number.
          - `basis` string, required: The quantity the price is quoted in: 'second' bills per second of generated output; 'megapixel_second' bills on frame area x duration, so resolution AND aspect ratio scale the cost, not just clip length; 'call' bills one flat price per generation, so the clip's running time does not move the charge at all — see higher_rate_durations for the clip lengths that carry a different flat price. Always present — a model whose basis is not expressible does not register.
          - `duration_quantity` string, required: The duration multiplied by a per-second basis: measured_output for ordinary generation, measured_input_audio when a driving track determines and meters the clip length, measured_whole_return when an extension bills source plus tail, or requested_extension when only the requested generated tail is metered.
          - `audio_priced_separately` boolean, required: Whether generate_audio=true bills a distinct (higher) rate than a silent render. False means audio is folded into one price.
          - `higher_rate_resolutions` string[], required: Resolutions whose RATE is above this mode's base rate. For a 'megapixel_second' basis every resolution already scales the cost by area, so this lists only extra rate tiers — and a resolution absent from it can still cost more, because the frame is larger. A provider may even meter a larger frame at a lower rate (Seedance 2.0's 4K), which is why this reads the rate rather than which resolutions carry their own price. Where the resolutions list is empty because the output follows a source video, these bands are selected by the SOURCE clip's measured frame rather than by anything the request carries.
          - `input_seconds_priced_separately` boolean, required: Whether every second of a source video adds a per-second charge on top of the returned clip's rate, on its own key. False means the source clip costs nothing beyond the mode's main price.
          - `higher_rate_durations` integer[], required: Clip lengths, in whole seconds, whose RATE is above this mode's base rate. Non-empty only where the provider publishes a separate price per clip length that is not a multiple of a per-second rate (Hailuo 2.3 standard: $0.28 for 6 seconds against $0.56 for 10). Empty means clip length either does not change the rate or scales it linearly through the basis above.
          - `reference_images_priced_separately` boolean, required: Whether each reference image adds a flat charge on top of the per-second rate, billed independently of clip length and resolution. False means reference images cost nothing beyond the mode's main price.
          - `reference_images_included_before_surcharge` integer, required: How many reference images carry no separate input surcharge. Meaningful only when reference_images_priced_separately is true.
      - `reference_to_video` PublicVideoModeCapability: One generation mode's real capability envelope for one model.
        - `aspect_ratios` string[], required: Aspect ratios the mode accepts ('auto' = the provider chooses the framing). Empty means the mode has no aspect control at all — the endpoint decides (an image route frames from its input still, a source_video mode from the source clip, a text route from the endpoint's own default), and a requested ratio is dropped and reported.
        - `default_aspect_ratio` string, nullable, required: The framing used when aspect_ratio is omitted; null when the mode has no aspect control.
        - `end_image_aspect_ratios` string[], nullable: The both-frames route's aspect ratios when they differ from the single-frame route.
        - `end_image_default_aspect_ratio` string, nullable: The both-frames route's default aspect ratio when that route has its own axis.
        - `resolutions` string[], required: Supported resolution tiers (for example 720p, 2k, or 4k). Actual pixel dimensions may depend on the selected aspect ratio or input image. Empty means the mode has no resolution control and a requested resolution is dropped and reported. What comes back instead: where the mode declares a source_video, the source clip's own frame size, which is also what selects the rate tier; otherwise read fixed_output_resolution, where a size is what the endpoint ALWAYS returns and only a null means the output size is genuinely not something we can state.
        - `default_resolution` string, nullable, required: The resolution used when resolution is omitted; null when the mode has no resolution control.
        - `fixed_output_resolution` string, nullable: The size this mode ALWAYS returns, where it has no resolution control to ask with. Null means the output size is not something we can state — not that it varies with the request. Read this rather than resolutions when resolutions is empty.
        - `duration_seconds` PublicVideoDuration, required: One mode's clip-length envelope, in whole seconds.
          - `min_seconds` integer, required: Shortest clip this mode can generate, in whole seconds. On a mode whose source_video reports output_includes_source, this is the length of the ADDED segment and the delivered clip is longer than it by the source's own running time — read source_video before budgeting from this number.
          - `max_seconds` integer, required: Longest clip this mode can generate, in whole seconds. On a mode whose source_video reports output_includes_source, this bounds the ADDED segment rather than the delivered clip, and the provider may meter the whole delivered clip or only the added segment; read billing.duration_quantity.
          - `allowed_seconds` integer[], nullable: The exact legal clip lengths, for a model that takes only fixed lengths (e.g. Veo's 4/6/8). null means every whole second in [min_seconds, max_seconds] is legal. Out-of-envelope asks snap to the nearest supported value and the adjustment is reported in the response.
          - `default` union, required: What runs when duration_seconds is omitted. A numeric value is a fixed default; 'auto' means omission itself lets the provider pick the clip length.
            - integer
            - 'auto'
          - `supports_auto` boolean, required: Whether the model can be asked to pick the clip length by passing duration_seconds="auto". Omitting duration_seconds takes default, which may independently be numeric or 'auto'.
          - `controllable` boolean: Whether duration_seconds is a control on this mode at all. False means the clip length is DERIVED from an input: an audio-driven mode renders to the driving track, and a lip-sync returns the source clip at its own length. Either way every explicit ask is answered with the input's measured length and reported as an adjustment, and the min/max here bound that input rather than a choice. Where this is false, read default and supports_auto as 'nothing to pick', not as 'the provider picks'.
        - `supports_end_image` boolean, required: image_to_video only: whether the request may carry end_image alongside start_image for a first-to-last-frame morph.
        - `end_image_duration_seconds` PublicVideoDuration: One mode's clip-length envelope, in whole seconds.
          - `min_seconds` integer, required: Shortest clip this mode can generate, in whole seconds. On a mode whose source_video reports output_includes_source, this is the length of the ADDED segment and the delivered clip is longer than it by the source's own running time — read source_video before budgeting from this number.
          - `max_seconds` integer, required: Longest clip this mode can generate, in whole seconds. On a mode whose source_video reports output_includes_source, this bounds the ADDED segment rather than the delivered clip, and the provider may meter the whole delivered clip or only the added segment; read billing.duration_quantity.
          - `allowed_seconds` integer[], nullable: The exact legal clip lengths, for a model that takes only fixed lengths (e.g. Veo's 4/6/8). null means every whole second in [min_seconds, max_seconds] is legal. Out-of-envelope asks snap to the nearest supported value and the adjustment is reported in the response.
          - `default` union, required: What runs when duration_seconds is omitted. A numeric value is a fixed default; 'auto' means omission itself lets the provider pick the clip length.
            - integer
            - 'auto'
          - `supports_auto` boolean, required: Whether the model can be asked to pick the clip length by passing duration_seconds="auto". Omitting duration_seconds takes default, which may independently be numeric or 'auto'.
          - `controllable` boolean: Whether duration_seconds is a control on this mode at all. False means the clip length is DERIVED from an input: an audio-driven mode renders to the driving track, and a lip-sync returns the source clip at its own length. Either way every explicit ask is answered with the input's measured length and reported as an adjustment, and the min/max here bound that input rather than a choice. Where this is false, read default and supports_auto as 'nothing to pick', not as 'the provider picks'.
        - `max_reference_images` integer, required: reference_to_video only: maximum reference_images one request may carry. 0 means the mode takes no reference images.
        - `reference_videos` PublicVideoReferenceVideos, required: The reference-VIDEO (video-to-video) envelope, where a mode has one.
          - `max_count` integer, required: Maximum reference clips one request may carry.
          - `min_seconds_each` number, required: Minimum running time per reference clip, in seconds.
          - `max_seconds_each` number, required: Maximum running time per reference clip, in seconds.
          - `max_total_seconds` number, required: Maximum combined running time across all reference clips.
          - `input_duration_billed` boolean, required: Whether the reference clips' own running time is billed on top of the generated clip's.
          - `price_multiplier` number, required: The provider's published factor a reference-video call's whole charge (including any billed input duration) is multiplied by. 1.0 means the provider publishes no factor.
          - `input_duration_price_multiplier` number, required: Factor applied only to billed reference-video duration; 1.0 means no input-only factor.
        - `reference_audios` PublicVideoReferenceAudios, required: The reference-audio envelope, where a mode has one.
          - `max_count` integer, required
          - `min_seconds_each` number, required
          - `max_seconds_each` number, required
          - `max_total_seconds` number, required
          - `requires_visual_reference` boolean, required: Whether at least one reference image or video must accompany reference audio.
          - `accepted_container_types` string[], nullable: Content types accepted for the driving track, where the mode derives the clip's length from it and bills that length. Only containers Moda measures frame by frame qualify; a container that merely declares its own duration is refused. Null where the mode does not bill the track, in which case every supported audio type is accepted.
        - `source_video` PublicVideoSourceVideo: The SOURCE-clip envelope for a mode that operates on an existing video. A source clip is the video being worked on, not one the model looks at for style or motion — see reference_videos for those. Moda measures the clip and refuses one outside this envelope before it is uploaded or persisted, so an out-of-envelope source costs nothing.
          - `min_seconds` number, nullable, required: Shortest source clip the mode accepts, if published.
          - `max_seconds` number, nullable, required: Longest source clip the mode accepts, if published.
          - `max_area_pixels` integer, nullable, required: Largest source frame the mode accepts, in total pixels (width x height). Stated as an area rather than a width and a height, which is how the provider enforces it: a portrait clip is accepted at the same pixel count as a landscape one.
          - `accepted_formats` string[], required: Container and codecs the provider documents for the source clip, and which Moda enforces against the clip's own bytes before uploading it: a container or a video codec outside this list is refused here rather than by the provider. A clip whose codec cannot be read is not refused — unknown is not the same as unsupported. Empty means the provider publishes no restriction and its own validation is the only gate.
          - `input_seconds_priced_separately` boolean, required: Whether every second of the SOURCE clip is billed on top of the returned clip's per-second charge. False means the source costs nothing beyond the mode's main price.
          - `output_includes_source` boolean, required: Whether the returned clip contains the source as well as the new footage. When true, duration_seconds is the length of the ADDED segment and the delivered video is longer than it by the source's own running time. Read billing.duration_quantity to learn whether the provider meters that whole return or only the requested extension.
        - `max_reference_inputs_total` integer, nullable, required: Maximum combined reference image, video, and audio count; null when there is no combined cap.
        - `image_requirements` PublicVideoImageRequirements[]: The provider's documented requirements for the images this mode is handed, one entry per group of roles sharing an envelope (roles never repeat across entries). Empty when the provider publishes none and its own validation is the only gate. Moda checks these before submitting whenever it already measured the property; for an image supplied as an external URL it has measured nothing, so the provider is the only gate.
          - `roles` string[], required: The image roles this envelope covers: 'start', 'end', and/or 'reference'.
          - `accepted_formats` string[], required: Accepted DECODED image formats (e.g. 'JPEG', 'PNG'). Empty means the provider publishes no format restriction. Matched against the decoded bytes, not the file name or Content-Type.
          - `max_bytes` integer, nullable, required: Largest accepted encoded image, in bytes. Applies per image, not to the set.
          - `min_width` integer, nullable, required: Smallest accepted width, in pixels.
          - `min_height` integer, nullable, required: Smallest accepted height, in pixels.
          - `max_pixels` integer, nullable, required: Largest accepted decoded size, in total pixels (width x height). May be a Moda platform ceiling rather than a provider-published one.
          - `min_aspect_ratio` number, nullable, required: Smallest accepted aspect ratio, measured as width divided by height, inclusive.
          - `max_aspect_ratio` number, nullable, required: Largest accepted aspect ratio, measured as width divided by height, inclusive.
        - `generate_audio_controllable` boolean, required: Whether generate_audio can be turned off ON THIS MODE. False means this endpoint has no such control: generate_audio=false is accepted, reported as an adjustment, and audio comes back anyway. The model-level field of the same name says it about every mode at once; this one can be false on a single mode while the model's others are controllable.
        - `billing` PublicVideoModeBilling, required: How this mode's provider cost is metered. No dollar or credit amount appears here, whatever the basis: the charge is computed asynchronously by the usage pipeline from the resolved request at the team's own credit rate, which this document cannot know. So this reports the BASIS and the knobs that move it — including `call`, where the provider quotes one flat price per generation and the clip's running time moves nothing. A flat basis still does not mean a publishable number.
          - `basis` string, required: The quantity the price is quoted in: 'second' bills per second of generated output; 'megapixel_second' bills on frame area x duration, so resolution AND aspect ratio scale the cost, not just clip length; 'call' bills one flat price per generation, so the clip's running time does not move the charge at all — see higher_rate_durations for the clip lengths that carry a different flat price. Always present — a model whose basis is not expressible does not register.
          - `duration_quantity` string, required: The duration multiplied by a per-second basis: measured_output for ordinary generation, measured_input_audio when a driving track determines and meters the clip length, measured_whole_return when an extension bills source plus tail, or requested_extension when only the requested generated tail is metered.
          - `audio_priced_separately` boolean, required: Whether generate_audio=true bills a distinct (higher) rate than a silent render. False means audio is folded into one price.
          - `higher_rate_resolutions` string[], required: Resolutions whose RATE is above this mode's base rate. For a 'megapixel_second' basis every resolution already scales the cost by area, so this lists only extra rate tiers — and a resolution absent from it can still cost more, because the frame is larger. A provider may even meter a larger frame at a lower rate (Seedance 2.0's 4K), which is why this reads the rate rather than which resolutions carry their own price. Where the resolutions list is empty because the output follows a source video, these bands are selected by the SOURCE clip's measured frame rather than by anything the request carries.
          - `input_seconds_priced_separately` boolean, required: Whether every second of a source video adds a per-second charge on top of the returned clip's rate, on its own key. False means the source clip costs nothing beyond the mode's main price.
          - `higher_rate_durations` integer[], required: Clip lengths, in whole seconds, whose RATE is above this mode's base rate. Non-empty only where the provider publishes a separate price per clip length that is not a multiple of a per-second rate (Hailuo 2.3 standard: $0.28 for 6 seconds against $0.56 for 10). Empty means clip length either does not change the rate or scales it linearly through the basis above.
          - `reference_images_priced_separately` boolean, required: Whether each reference image adds a flat charge on top of the per-second rate, billed independently of clip length and resolution. False means reference images cost nothing beyond the mode's main price.
          - `reference_images_included_before_surcharge` integer, required: How many reference images carry no separate input surcharge. Meaningful only when reference_images_priced_separately is true.
      - `audio_to_video` PublicVideoModeCapability: One generation mode's real capability envelope for one model.
        - `aspect_ratios` string[], required: Aspect ratios the mode accepts ('auto' = the provider chooses the framing). Empty means the mode has no aspect control at all — the endpoint decides (an image route frames from its input still, a source_video mode from the source clip, a text route from the endpoint's own default), and a requested ratio is dropped and reported.
        - `default_aspect_ratio` string, nullable, required: The framing used when aspect_ratio is omitted; null when the mode has no aspect control.
        - `end_image_aspect_ratios` string[], nullable: The both-frames route's aspect ratios when they differ from the single-frame route.
        - `end_image_default_aspect_ratio` string, nullable: The both-frames route's default aspect ratio when that route has its own axis.
        - `resolutions` string[], required: Supported resolution tiers (for example 720p, 2k, or 4k). Actual pixel dimensions may depend on the selected aspect ratio or input image. Empty means the mode has no resolution control and a requested resolution is dropped and reported. What comes back instead: where the mode declares a source_video, the source clip's own frame size, which is also what selects the rate tier; otherwise read fixed_output_resolution, where a size is what the endpoint ALWAYS returns and only a null means the output size is genuinely not something we can state.
        - `default_resolution` string, nullable, required: The resolution used when resolution is omitted; null when the mode has no resolution control.
        - `fixed_output_resolution` string, nullable: The size this mode ALWAYS returns, where it has no resolution control to ask with. Null means the output size is not something we can state — not that it varies with the request. Read this rather than resolutions when resolutions is empty.
        - `duration_seconds` PublicVideoDuration, required: One mode's clip-length envelope, in whole seconds.
          - `min_seconds` integer, required: Shortest clip this mode can generate, in whole seconds. On a mode whose source_video reports output_includes_source, this is the length of the ADDED segment and the delivered clip is longer than it by the source's own running time — read source_video before budgeting from this number.
          - `max_seconds` integer, required: Longest clip this mode can generate, in whole seconds. On a mode whose source_video reports output_includes_source, this bounds the ADDED segment rather than the delivered clip, and the provider may meter the whole delivered clip or only the added segment; read billing.duration_quantity.
          - `allowed_seconds` integer[], nullable: The exact legal clip lengths, for a model that takes only fixed lengths (e.g. Veo's 4/6/8). null means every whole second in [min_seconds, max_seconds] is legal. Out-of-envelope asks snap to the nearest supported value and the adjustment is reported in the response.
          - `default` union, required: What runs when duration_seconds is omitted. A numeric value is a fixed default; 'auto' means omission itself lets the provider pick the clip length.
            - integer
            - 'auto'
          - `supports_auto` boolean, required: Whether the model can be asked to pick the clip length by passing duration_seconds="auto". Omitting duration_seconds takes default, which may independently be numeric or 'auto'.
          - `controllable` boolean: Whether duration_seconds is a control on this mode at all. False means the clip length is DERIVED from an input: an audio-driven mode renders to the driving track, and a lip-sync returns the source clip at its own length. Either way every explicit ask is answered with the input's measured length and reported as an adjustment, and the min/max here bound that input rather than a choice. Where this is false, read default and supports_auto as 'nothing to pick', not as 'the provider picks'.
        - `supports_end_image` boolean, required: image_to_video only: whether the request may carry end_image alongside start_image for a first-to-last-frame morph.
        - `end_image_duration_seconds` PublicVideoDuration: One mode's clip-length envelope, in whole seconds.
          - `min_seconds` integer, required: Shortest clip this mode can generate, in whole seconds. On a mode whose source_video reports output_includes_source, this is the length of the ADDED segment and the delivered clip is longer than it by the source's own running time — read source_video before budgeting from this number.
          - `max_seconds` integer, required: Longest clip this mode can generate, in whole seconds. On a mode whose source_video reports output_includes_source, this bounds the ADDED segment rather than the delivered clip, and the provider may meter the whole delivered clip or only the added segment; read billing.duration_quantity.
          - `allowed_seconds` integer[], nullable: The exact legal clip lengths, for a model that takes only fixed lengths (e.g. Veo's 4/6/8). null means every whole second in [min_seconds, max_seconds] is legal. Out-of-envelope asks snap to the nearest supported value and the adjustment is reported in the response.
          - `default` union, required: What runs when duration_seconds is omitted. A numeric value is a fixed default; 'auto' means omission itself lets the provider pick the clip length.
            - integer
            - 'auto'
          - `supports_auto` boolean, required: Whether the model can be asked to pick the clip length by passing duration_seconds="auto". Omitting duration_seconds takes default, which may independently be numeric or 'auto'.
          - `controllable` boolean: Whether duration_seconds is a control on this mode at all. False means the clip length is DERIVED from an input: an audio-driven mode renders to the driving track, and a lip-sync returns the source clip at its own length. Either way every explicit ask is answered with the input's measured length and reported as an adjustment, and the min/max here bound that input rather than a choice. Where this is false, read default and supports_auto as 'nothing to pick', not as 'the provider picks'.
        - `max_reference_images` integer, required: reference_to_video only: maximum reference_images one request may carry. 0 means the mode takes no reference images.
        - `reference_videos` PublicVideoReferenceVideos, required: The reference-VIDEO (video-to-video) envelope, where a mode has one.
          - `max_count` integer, required: Maximum reference clips one request may carry.
          - `min_seconds_each` number, required: Minimum running time per reference clip, in seconds.
          - `max_seconds_each` number, required: Maximum running time per reference clip, in seconds.
          - `max_total_seconds` number, required: Maximum combined running time across all reference clips.
          - `input_duration_billed` boolean, required: Whether the reference clips' own running time is billed on top of the generated clip's.
          - `price_multiplier` number, required: The provider's published factor a reference-video call's whole charge (including any billed input duration) is multiplied by. 1.0 means the provider publishes no factor.
          - `input_duration_price_multiplier` number, required: Factor applied only to billed reference-video duration; 1.0 means no input-only factor.
        - `reference_audios` PublicVideoReferenceAudios, required: The reference-audio envelope, where a mode has one.
          - `max_count` integer, required
          - `min_seconds_each` number, required
          - `max_seconds_each` number, required
          - `max_total_seconds` number, required
          - `requires_visual_reference` boolean, required: Whether at least one reference image or video must accompany reference audio.
          - `accepted_container_types` string[], nullable: Content types accepted for the driving track, where the mode derives the clip's length from it and bills that length. Only containers Moda measures frame by frame qualify; a container that merely declares its own duration is refused. Null where the mode does not bill the track, in which case every supported audio type is accepted.
        - `source_video` PublicVideoSourceVideo: The SOURCE-clip envelope for a mode that operates on an existing video. A source clip is the video being worked on, not one the model looks at for style or motion — see reference_videos for those. Moda measures the clip and refuses one outside this envelope before it is uploaded or persisted, so an out-of-envelope source costs nothing.
          - `min_seconds` number, nullable, required: Shortest source clip the mode accepts, if published.
          - `max_seconds` number, nullable, required: Longest source clip the mode accepts, if published.
          - `max_area_pixels` integer, nullable, required: Largest source frame the mode accepts, in total pixels (width x height). Stated as an area rather than a width and a height, which is how the provider enforces it: a portrait clip is accepted at the same pixel count as a landscape one.
          - `accepted_formats` string[], required: Container and codecs the provider documents for the source clip, and which Moda enforces against the clip's own bytes before uploading it: a container or a video codec outside this list is refused here rather than by the provider. A clip whose codec cannot be read is not refused — unknown is not the same as unsupported. Empty means the provider publishes no restriction and its own validation is the only gate.
          - `input_seconds_priced_separately` boolean, required: Whether every second of the SOURCE clip is billed on top of the returned clip's per-second charge. False means the source costs nothing beyond the mode's main price.
          - `output_includes_source` boolean, required: Whether the returned clip contains the source as well as the new footage. When true, duration_seconds is the length of the ADDED segment and the delivered video is longer than it by the source's own running time. Read billing.duration_quantity to learn whether the provider meters that whole return or only the requested extension.
        - `max_reference_inputs_total` integer, nullable, required: Maximum combined reference image, video, and audio count; null when there is no combined cap.
        - `image_requirements` PublicVideoImageRequirements[]: The provider's documented requirements for the images this mode is handed, one entry per group of roles sharing an envelope (roles never repeat across entries). Empty when the provider publishes none and its own validation is the only gate. Moda checks these before submitting whenever it already measured the property; for an image supplied as an external URL it has measured nothing, so the provider is the only gate.
          - `roles` string[], required: The image roles this envelope covers: 'start', 'end', and/or 'reference'.
          - `accepted_formats` string[], required: Accepted DECODED image formats (e.g. 'JPEG', 'PNG'). Empty means the provider publishes no format restriction. Matched against the decoded bytes, not the file name or Content-Type.
          - `max_bytes` integer, nullable, required: Largest accepted encoded image, in bytes. Applies per image, not to the set.
          - `min_width` integer, nullable, required: Smallest accepted width, in pixels.
          - `min_height` integer, nullable, required: Smallest accepted height, in pixels.
          - `max_pixels` integer, nullable, required: Largest accepted decoded size, in total pixels (width x height). May be a Moda platform ceiling rather than a provider-published one.
          - `min_aspect_ratio` number, nullable, required: Smallest accepted aspect ratio, measured as width divided by height, inclusive.
          - `max_aspect_ratio` number, nullable, required: Largest accepted aspect ratio, measured as width divided by height, inclusive.
        - `generate_audio_controllable` boolean, required: Whether generate_audio can be turned off ON THIS MODE. False means this endpoint has no such control: generate_audio=false is accepted, reported as an adjustment, and audio comes back anyway. The model-level field of the same name says it about every mode at once; this one can be false on a single mode while the model's others are controllable.
        - `billing` PublicVideoModeBilling, required: How this mode's provider cost is metered. No dollar or credit amount appears here, whatever the basis: the charge is computed asynchronously by the usage pipeline from the resolved request at the team's own credit rate, which this document cannot know. So this reports the BASIS and the knobs that move it — including `call`, where the provider quotes one flat price per generation and the clip's running time moves nothing. A flat basis still does not mean a publishable number.
          - `basis` string, required: The quantity the price is quoted in: 'second' bills per second of generated output; 'megapixel_second' bills on frame area x duration, so resolution AND aspect ratio scale the cost, not just clip length; 'call' bills one flat price per generation, so the clip's running time does not move the charge at all — see higher_rate_durations for the clip lengths that carry a different flat price. Always present — a model whose basis is not expressible does not register.
          - `duration_quantity` string, required: The duration multiplied by a per-second basis: measured_output for ordinary generation, measured_input_audio when a driving track determines and meters the clip length, measured_whole_return when an extension bills source plus tail, or requested_extension when only the requested generated tail is metered.
          - `audio_priced_separately` boolean, required: Whether generate_audio=true bills a distinct (higher) rate than a silent render. False means audio is folded into one price.
          - `higher_rate_resolutions` string[], required: Resolutions whose RATE is above this mode's base rate. For a 'megapixel_second' basis every resolution already scales the cost by area, so this lists only extra rate tiers — and a resolution absent from it can still cost more, because the frame is larger. A provider may even meter a larger frame at a lower rate (Seedance 2.0's 4K), which is why this reads the rate rather than which resolutions carry their own price. Where the resolutions list is empty because the output follows a source video, these bands are selected by the SOURCE clip's measured frame rather than by anything the request carries.
          - `input_seconds_priced_separately` boolean, required: Whether every second of a source video adds a per-second charge on top of the returned clip's rate, on its own key. False means the source clip costs nothing beyond the mode's main price.
          - `higher_rate_durations` integer[], required: Clip lengths, in whole seconds, whose RATE is above this mode's base rate. Non-empty only where the provider publishes a separate price per clip length that is not a multiple of a per-second rate (Hailuo 2.3 standard: $0.28 for 6 seconds against $0.56 for 10). Empty means clip length either does not change the rate or scales it linearly through the basis above.
          - `reference_images_priced_separately` boolean, required: Whether each reference image adds a flat charge on top of the per-second rate, billed independently of clip length and resolution. False means reference images cost nothing beyond the mode's main price.
          - `reference_images_included_before_surcharge` integer, required: How many reference images carry no separate input surcharge. Meaningful only when reference_images_priced_separately is true.
      - `video_extend` PublicVideoModeCapability: One generation mode's real capability envelope for one model.
        - `aspect_ratios` string[], required: Aspect ratios the mode accepts ('auto' = the provider chooses the framing). Empty means the mode has no aspect control at all — the endpoint decides (an image route frames from its input still, a source_video mode from the source clip, a text route from the endpoint's own default), and a requested ratio is dropped and reported.
        - `default_aspect_ratio` string, nullable, required: The framing used when aspect_ratio is omitted; null when the mode has no aspect control.
        - `end_image_aspect_ratios` string[], nullable: The both-frames route's aspect ratios when they differ from the single-frame route.
        - `end_image_default_aspect_ratio` string, nullable: The both-frames route's default aspect ratio when that route has its own axis.
        - `resolutions` string[], required: Supported resolution tiers (for example 720p, 2k, or 4k). Actual pixel dimensions may depend on the selected aspect ratio or input image. Empty means the mode has no resolution control and a requested resolution is dropped and reported. What comes back instead: where the mode declares a source_video, the source clip's own frame size, which is also what selects the rate tier; otherwise read fixed_output_resolution, where a size is what the endpoint ALWAYS returns and only a null means the output size is genuinely not something we can state.
        - `default_resolution` string, nullable, required: The resolution used when resolution is omitted; null when the mode has no resolution control.
        - `fixed_output_resolution` string, nullable: The size this mode ALWAYS returns, where it has no resolution control to ask with. Null means the output size is not something we can state — not that it varies with the request. Read this rather than resolutions when resolutions is empty.
        - `duration_seconds` PublicVideoDuration, required: One mode's clip-length envelope, in whole seconds.
          - `min_seconds` integer, required: Shortest clip this mode can generate, in whole seconds. On a mode whose source_video reports output_includes_source, this is the length of the ADDED segment and the delivered clip is longer than it by the source's own running time — read source_video before budgeting from this number.
          - `max_seconds` integer, required: Longest clip this mode can generate, in whole seconds. On a mode whose source_video reports output_includes_source, this bounds the ADDED segment rather than the delivered clip, and the provider may meter the whole delivered clip or only the added segment; read billing.duration_quantity.
          - `allowed_seconds` integer[], nullable: The exact legal clip lengths, for a model that takes only fixed lengths (e.g. Veo's 4/6/8). null means every whole second in [min_seconds, max_seconds] is legal. Out-of-envelope asks snap to the nearest supported value and the adjustment is reported in the response.
          - `default` union, required: What runs when duration_seconds is omitted. A numeric value is a fixed default; 'auto' means omission itself lets the provider pick the clip length.
            - integer
            - 'auto'
          - `supports_auto` boolean, required: Whether the model can be asked to pick the clip length by passing duration_seconds="auto". Omitting duration_seconds takes default, which may independently be numeric or 'auto'.
          - `controllable` boolean: Whether duration_seconds is a control on this mode at all. False means the clip length is DERIVED from an input: an audio-driven mode renders to the driving track, and a lip-sync returns the source clip at its own length. Either way every explicit ask is answered with the input's measured length and reported as an adjustment, and the min/max here bound that input rather than a choice. Where this is false, read default and supports_auto as 'nothing to pick', not as 'the provider picks'.
        - `supports_end_image` boolean, required: image_to_video only: whether the request may carry end_image alongside start_image for a first-to-last-frame morph.
        - `end_image_duration_seconds` PublicVideoDuration: One mode's clip-length envelope, in whole seconds.
          - `min_seconds` integer, required: Shortest clip this mode can generate, in whole seconds. On a mode whose source_video reports output_includes_source, this is the length of the ADDED segment and the delivered clip is longer than it by the source's own running time — read source_video before budgeting from this number.
          - `max_seconds` integer, required: Longest clip this mode can generate, in whole seconds. On a mode whose source_video reports output_includes_source, this bounds the ADDED segment rather than the delivered clip, and the provider may meter the whole delivered clip or only the added segment; read billing.duration_quantity.
          - `allowed_seconds` integer[], nullable: The exact legal clip lengths, for a model that takes only fixed lengths (e.g. Veo's 4/6/8). null means every whole second in [min_seconds, max_seconds] is legal. Out-of-envelope asks snap to the nearest supported value and the adjustment is reported in the response.
          - `default` union, required: What runs when duration_seconds is omitted. A numeric value is a fixed default; 'auto' means omission itself lets the provider pick the clip length.
            - integer
            - 'auto'
          - `supports_auto` boolean, required: Whether the model can be asked to pick the clip length by passing duration_seconds="auto". Omitting duration_seconds takes default, which may independently be numeric or 'auto'.
          - `controllable` boolean: Whether duration_seconds is a control on this mode at all. False means the clip length is DERIVED from an input: an audio-driven mode renders to the driving track, and a lip-sync returns the source clip at its own length. Either way every explicit ask is answered with the input's measured length and reported as an adjustment, and the min/max here bound that input rather than a choice. Where this is false, read default and supports_auto as 'nothing to pick', not as 'the provider picks'.
        - `max_reference_images` integer, required: reference_to_video only: maximum reference_images one request may carry. 0 means the mode takes no reference images.
        - `reference_videos` PublicVideoReferenceVideos, required: The reference-VIDEO (video-to-video) envelope, where a mode has one.
          - `max_count` integer, required: Maximum reference clips one request may carry.
          - `min_seconds_each` number, required: Minimum running time per reference clip, in seconds.
          - `max_seconds_each` number, required: Maximum running time per reference clip, in seconds.
          - `max_total_seconds` number, required: Maximum combined running time across all reference clips.
          - `input_duration_billed` boolean, required: Whether the reference clips' own running time is billed on top of the generated clip's.
          - `price_multiplier` number, required: The provider's published factor a reference-video call's whole charge (including any billed input duration) is multiplied by. 1.0 means the provider publishes no factor.
          - `input_duration_price_multiplier` number, required: Factor applied only to billed reference-video duration; 1.0 means no input-only factor.
        - `reference_audios` PublicVideoReferenceAudios, required: The reference-audio envelope, where a mode has one.
          - `max_count` integer, required
          - `min_seconds_each` number, required
          - `max_seconds_each` number, required
          - `max_total_seconds` number, required
          - `requires_visual_reference` boolean, required: Whether at least one reference image or video must accompany reference audio.
          - `accepted_container_types` string[], nullable: Content types accepted for the driving track, where the mode derives the clip's length from it and bills that length. Only containers Moda measures frame by frame qualify; a container that merely declares its own duration is refused. Null where the mode does not bill the track, in which case every supported audio type is accepted.
        - `source_video` PublicVideoSourceVideo: The SOURCE-clip envelope for a mode that operates on an existing video. A source clip is the video being worked on, not one the model looks at for style or motion — see reference_videos for those. Moda measures the clip and refuses one outside this envelope before it is uploaded or persisted, so an out-of-envelope source costs nothing.
          - `min_seconds` number, nullable, required: Shortest source clip the mode accepts, if published.
          - `max_seconds` number, nullable, required: Longest source clip the mode accepts, if published.
          - `max_area_pixels` integer, nullable, required: Largest source frame the mode accepts, in total pixels (width x height). Stated as an area rather than a width and a height, which is how the provider enforces it: a portrait clip is accepted at the same pixel count as a landscape one.
          - `accepted_formats` string[], required: Container and codecs the provider documents for the source clip, and which Moda enforces against the clip's own bytes before uploading it: a container or a video codec outside this list is refused here rather than by the provider. A clip whose codec cannot be read is not refused — unknown is not the same as unsupported. Empty means the provider publishes no restriction and its own validation is the only gate.
          - `input_seconds_priced_separately` boolean, required: Whether every second of the SOURCE clip is billed on top of the returned clip's per-second charge. False means the source costs nothing beyond the mode's main price.
          - `output_includes_source` boolean, required: Whether the returned clip contains the source as well as the new footage. When true, duration_seconds is the length of the ADDED segment and the delivered video is longer than it by the source's own running time. Read billing.duration_quantity to learn whether the provider meters that whole return or only the requested extension.
        - `max_reference_inputs_total` integer, nullable, required: Maximum combined reference image, video, and audio count; null when there is no combined cap.
        - `image_requirements` PublicVideoImageRequirements[]: The provider's documented requirements for the images this mode is handed, one entry per group of roles sharing an envelope (roles never repeat across entries). Empty when the provider publishes none and its own validation is the only gate. Moda checks these before submitting whenever it already measured the property; for an image supplied as an external URL it has measured nothing, so the provider is the only gate.
          - `roles` string[], required: The image roles this envelope covers: 'start', 'end', and/or 'reference'.
          - `accepted_formats` string[], required: Accepted DECODED image formats (e.g. 'JPEG', 'PNG'). Empty means the provider publishes no format restriction. Matched against the decoded bytes, not the file name or Content-Type.
          - `max_bytes` integer, nullable, required: Largest accepted encoded image, in bytes. Applies per image, not to the set.
          - `min_width` integer, nullable, required: Smallest accepted width, in pixels.
          - `min_height` integer, nullable, required: Smallest accepted height, in pixels.
          - `max_pixels` integer, nullable, required: Largest accepted decoded size, in total pixels (width x height). May be a Moda platform ceiling rather than a provider-published one.
          - `min_aspect_ratio` number, nullable, required: Smallest accepted aspect ratio, measured as width divided by height, inclusive.
          - `max_aspect_ratio` number, nullable, required: Largest accepted aspect ratio, measured as width divided by height, inclusive.
        - `generate_audio_controllable` boolean, required: Whether generate_audio can be turned off ON THIS MODE. False means this endpoint has no such control: generate_audio=false is accepted, reported as an adjustment, and audio comes back anyway. The model-level field of the same name says it about every mode at once; this one can be false on a single mode while the model's others are controllable.
        - `billing` PublicVideoModeBilling, required: How this mode's provider cost is metered. No dollar or credit amount appears here, whatever the basis: the charge is computed asynchronously by the usage pipeline from the resolved request at the team's own credit rate, which this document cannot know. So this reports the BASIS and the knobs that move it — including `call`, where the provider quotes one flat price per generation and the clip's running time moves nothing. A flat basis still does not mean a publishable number.
          - `basis` string, required: The quantity the price is quoted in: 'second' bills per second of generated output; 'megapixel_second' bills on frame area x duration, so resolution AND aspect ratio scale the cost, not just clip length; 'call' bills one flat price per generation, so the clip's running time does not move the charge at all — see higher_rate_durations for the clip lengths that carry a different flat price. Always present — a model whose basis is not expressible does not register.
          - `duration_quantity` string, required: The duration multiplied by a per-second basis: measured_output for ordinary generation, measured_input_audio when a driving track determines and meters the clip length, measured_whole_return when an extension bills source plus tail, or requested_extension when only the requested generated tail is metered.
          - `audio_priced_separately` boolean, required: Whether generate_audio=true bills a distinct (higher) rate than a silent render. False means audio is folded into one price.
          - `higher_rate_resolutions` string[], required: Resolutions whose RATE is above this mode's base rate. For a 'megapixel_second' basis every resolution already scales the cost by area, so this lists only extra rate tiers — and a resolution absent from it can still cost more, because the frame is larger. A provider may even meter a larger frame at a lower rate (Seedance 2.0's 4K), which is why this reads the rate rather than which resolutions carry their own price. Where the resolutions list is empty because the output follows a source video, these bands are selected by the SOURCE clip's measured frame rather than by anything the request carries.
          - `input_seconds_priced_separately` boolean, required: Whether every second of a source video adds a per-second charge on top of the returned clip's rate, on its own key. False means the source clip costs nothing beyond the mode's main price.
          - `higher_rate_durations` integer[], required: Clip lengths, in whole seconds, whose RATE is above this mode's base rate. Non-empty only where the provider publishes a separate price per clip length that is not a multiple of a per-second rate (Hailuo 2.3 standard: $0.28 for 6 seconds against $0.56 for 10). Empty means clip length either does not change the rate or scales it linearly through the basis above.
          - `reference_images_priced_separately` boolean, required: Whether each reference image adds a flat charge on top of the per-second rate, billed independently of clip length and resolution. False means reference images cost nothing beyond the mode's main price.
          - `reference_images_included_before_surcharge` integer, required: How many reference images carry no separate input surcharge. Meaningful only when reference_images_priced_separately is true.
      - `video_lipsync` PublicVideoModeCapability: One generation mode's real capability envelope for one model.
        - `aspect_ratios` string[], required: Aspect ratios the mode accepts ('auto' = the provider chooses the framing). Empty means the mode has no aspect control at all — the endpoint decides (an image route frames from its input still, a source_video mode from the source clip, a text route from the endpoint's own default), and a requested ratio is dropped and reported.
        - `default_aspect_ratio` string, nullable, required: The framing used when aspect_ratio is omitted; null when the mode has no aspect control.
        - `end_image_aspect_ratios` string[], nullable: The both-frames route's aspect ratios when they differ from the single-frame route.
        - `end_image_default_aspect_ratio` string, nullable: The both-frames route's default aspect ratio when that route has its own axis.
        - `resolutions` string[], required: Supported resolution tiers (for example 720p, 2k, or 4k). Actual pixel dimensions may depend on the selected aspect ratio or input image. Empty means the mode has no resolution control and a requested resolution is dropped and reported. What comes back instead: where the mode declares a source_video, the source clip's own frame size, which is also what selects the rate tier; otherwise read fixed_output_resolution, where a size is what the endpoint ALWAYS returns and only a null means the output size is genuinely not something we can state.
        - `default_resolution` string, nullable, required: The resolution used when resolution is omitted; null when the mode has no resolution control.
        - `fixed_output_resolution` string, nullable: The size this mode ALWAYS returns, where it has no resolution control to ask with. Null means the output size is not something we can state — not that it varies with the request. Read this rather than resolutions when resolutions is empty.
        - `duration_seconds` PublicVideoDuration, required: One mode's clip-length envelope, in whole seconds.
          - `min_seconds` integer, required: Shortest clip this mode can generate, in whole seconds. On a mode whose source_video reports output_includes_source, this is the length of the ADDED segment and the delivered clip is longer than it by the source's own running time — read source_video before budgeting from this number.
          - `max_seconds` integer, required: Longest clip this mode can generate, in whole seconds. On a mode whose source_video reports output_includes_source, this bounds the ADDED segment rather than the delivered clip, and the provider may meter the whole delivered clip or only the added segment; read billing.duration_quantity.
          - `allowed_seconds` integer[], nullable: The exact legal clip lengths, for a model that takes only fixed lengths (e.g. Veo's 4/6/8). null means every whole second in [min_seconds, max_seconds] is legal. Out-of-envelope asks snap to the nearest supported value and the adjustment is reported in the response.
          - `default` union, required: What runs when duration_seconds is omitted. A numeric value is a fixed default; 'auto' means omission itself lets the provider pick the clip length.
            - integer
            - 'auto'
          - `supports_auto` boolean, required: Whether the model can be asked to pick the clip length by passing duration_seconds="auto". Omitting duration_seconds takes default, which may independently be numeric or 'auto'.
          - `controllable` boolean: Whether duration_seconds is a control on this mode at all. False means the clip length is DERIVED from an input: an audio-driven mode renders to the driving track, and a lip-sync returns the source clip at its own length. Either way every explicit ask is answered with the input's measured length and reported as an adjustment, and the min/max here bound that input rather than a choice. Where this is false, read default and supports_auto as 'nothing to pick', not as 'the provider picks'.
        - `supports_end_image` boolean, required: image_to_video only: whether the request may carry end_image alongside start_image for a first-to-last-frame morph.
        - `end_image_duration_seconds` PublicVideoDuration: One mode's clip-length envelope, in whole seconds.
          - `min_seconds` integer, required: Shortest clip this mode can generate, in whole seconds. On a mode whose source_video reports output_includes_source, this is the length of the ADDED segment and the delivered clip is longer than it by the source's own running time — read source_video before budgeting from this number.
          - `max_seconds` integer, required: Longest clip this mode can generate, in whole seconds. On a mode whose source_video reports output_includes_source, this bounds the ADDED segment rather than the delivered clip, and the provider may meter the whole delivered clip or only the added segment; read billing.duration_quantity.
          - `allowed_seconds` integer[], nullable: The exact legal clip lengths, for a model that takes only fixed lengths (e.g. Veo's 4/6/8). null means every whole second in [min_seconds, max_seconds] is legal. Out-of-envelope asks snap to the nearest supported value and the adjustment is reported in the response.
          - `default` union, required: What runs when duration_seconds is omitted. A numeric value is a fixed default; 'auto' means omission itself lets the provider pick the clip length.
            - integer
            - 'auto'
          - `supports_auto` boolean, required: Whether the model can be asked to pick the clip length by passing duration_seconds="auto". Omitting duration_seconds takes default, which may independently be numeric or 'auto'.
          - `controllable` boolean: Whether duration_seconds is a control on this mode at all. False means the clip length is DERIVED from an input: an audio-driven mode renders to the driving track, and a lip-sync returns the source clip at its own length. Either way every explicit ask is answered with the input's measured length and reported as an adjustment, and the min/max here bound that input rather than a choice. Where this is false, read default and supports_auto as 'nothing to pick', not as 'the provider picks'.
        - `max_reference_images` integer, required: reference_to_video only: maximum reference_images one request may carry. 0 means the mode takes no reference images.
        - `reference_videos` PublicVideoReferenceVideos, required: The reference-VIDEO (video-to-video) envelope, where a mode has one.
          - `max_count` integer, required: Maximum reference clips one request may carry.
          - `min_seconds_each` number, required: Minimum running time per reference clip, in seconds.
          - `max_seconds_each` number, required: Maximum running time per reference clip, in seconds.
          - `max_total_seconds` number, required: Maximum combined running time across all reference clips.
          - `input_duration_billed` boolean, required: Whether the reference clips' own running time is billed on top of the generated clip's.
          - `price_multiplier` number, required: The provider's published factor a reference-video call's whole charge (including any billed input duration) is multiplied by. 1.0 means the provider publishes no factor.
          - `input_duration_price_multiplier` number, required: Factor applied only to billed reference-video duration; 1.0 means no input-only factor.
        - `reference_audios` PublicVideoReferenceAudios, required: The reference-audio envelope, where a mode has one.
          - `max_count` integer, required
          - `min_seconds_each` number, required
          - `max_seconds_each` number, required
          - `max_total_seconds` number, required
          - `requires_visual_reference` boolean, required: Whether at least one reference image or video must accompany reference audio.
          - `accepted_container_types` string[], nullable: Content types accepted for the driving track, where the mode derives the clip's length from it and bills that length. Only containers Moda measures frame by frame qualify; a container that merely declares its own duration is refused. Null where the mode does not bill the track, in which case every supported audio type is accepted.
        - `source_video` PublicVideoSourceVideo: The SOURCE-clip envelope for a mode that operates on an existing video. A source clip is the video being worked on, not one the model looks at for style or motion — see reference_videos for those. Moda measures the clip and refuses one outside this envelope before it is uploaded or persisted, so an out-of-envelope source costs nothing.
          - `min_seconds` number, nullable, required: Shortest source clip the mode accepts, if published.
          - `max_seconds` number, nullable, required: Longest source clip the mode accepts, if published.
          - `max_area_pixels` integer, nullable, required: Largest source frame the mode accepts, in total pixels (width x height). Stated as an area rather than a width and a height, which is how the provider enforces it: a portrait clip is accepted at the same pixel count as a landscape one.
          - `accepted_formats` string[], required: Container and codecs the provider documents for the source clip, and which Moda enforces against the clip's own bytes before uploading it: a container or a video codec outside this list is refused here rather than by the provider. A clip whose codec cannot be read is not refused — unknown is not the same as unsupported. Empty means the provider publishes no restriction and its own validation is the only gate.
          - `input_seconds_priced_separately` boolean, required: Whether every second of the SOURCE clip is billed on top of the returned clip's per-second charge. False means the source costs nothing beyond the mode's main price.
          - `output_includes_source` boolean, required: Whether the returned clip contains the source as well as the new footage. When true, duration_seconds is the length of the ADDED segment and the delivered video is longer than it by the source's own running time. Read billing.duration_quantity to learn whether the provider meters that whole return or only the requested extension.
        - `max_reference_inputs_total` integer, nullable, required: Maximum combined reference image, video, and audio count; null when there is no combined cap.
        - `image_requirements` PublicVideoImageRequirements[]: The provider's documented requirements for the images this mode is handed, one entry per group of roles sharing an envelope (roles never repeat across entries). Empty when the provider publishes none and its own validation is the only gate. Moda checks these before submitting whenever it already measured the property; for an image supplied as an external URL it has measured nothing, so the provider is the only gate.
          - `roles` string[], required: The image roles this envelope covers: 'start', 'end', and/or 'reference'.
          - `accepted_formats` string[], required: Accepted DECODED image formats (e.g. 'JPEG', 'PNG'). Empty means the provider publishes no format restriction. Matched against the decoded bytes, not the file name or Content-Type.
          - `max_bytes` integer, nullable, required: Largest accepted encoded image, in bytes. Applies per image, not to the set.
          - `min_width` integer, nullable, required: Smallest accepted width, in pixels.
          - `min_height` integer, nullable, required: Smallest accepted height, in pixels.
          - `max_pixels` integer, nullable, required: Largest accepted decoded size, in total pixels (width x height). May be a Moda platform ceiling rather than a provider-published one.
          - `min_aspect_ratio` number, nullable, required: Smallest accepted aspect ratio, measured as width divided by height, inclusive.
          - `max_aspect_ratio` number, nullable, required: Largest accepted aspect ratio, measured as width divided by height, inclusive.
        - `generate_audio_controllable` boolean, required: Whether generate_audio can be turned off ON THIS MODE. False means this endpoint has no such control: generate_audio=false is accepted, reported as an adjustment, and audio comes back anyway. The model-level field of the same name says it about every mode at once; this one can be false on a single mode while the model's others are controllable.
        - `billing` PublicVideoModeBilling, required: How this mode's provider cost is metered. No dollar or credit amount appears here, whatever the basis: the charge is computed asynchronously by the usage pipeline from the resolved request at the team's own credit rate, which this document cannot know. So this reports the BASIS and the knobs that move it — including `call`, where the provider quotes one flat price per generation and the clip's running time moves nothing. A flat basis still does not mean a publishable number.
          - `basis` string, required: The quantity the price is quoted in: 'second' bills per second of generated output; 'megapixel_second' bills on frame area x duration, so resolution AND aspect ratio scale the cost, not just clip length; 'call' bills one flat price per generation, so the clip's running time does not move the charge at all — see higher_rate_durations for the clip lengths that carry a different flat price. Always present — a model whose basis is not expressible does not register.
          - `duration_quantity` string, required: The duration multiplied by a per-second basis: measured_output for ordinary generation, measured_input_audio when a driving track determines and meters the clip length, measured_whole_return when an extension bills source plus tail, or requested_extension when only the requested generated tail is metered.
          - `audio_priced_separately` boolean, required: Whether generate_audio=true bills a distinct (higher) rate than a silent render. False means audio is folded into one price.
          - `higher_rate_resolutions` string[], required: Resolutions whose RATE is above this mode's base rate. For a 'megapixel_second' basis every resolution already scales the cost by area, so this lists only extra rate tiers — and a resolution absent from it can still cost more, because the frame is larger. A provider may even meter a larger frame at a lower rate (Seedance 2.0's 4K), which is why this reads the rate rather than which resolutions carry their own price. Where the resolutions list is empty because the output follows a source video, these bands are selected by the SOURCE clip's measured frame rather than by anything the request carries.
          - `input_seconds_priced_separately` boolean, required: Whether every second of a source video adds a per-second charge on top of the returned clip's rate, on its own key. False means the source clip costs nothing beyond the mode's main price.
          - `higher_rate_durations` integer[], required: Clip lengths, in whole seconds, whose RATE is above this mode's base rate. Non-empty only where the provider publishes a separate price per clip length that is not a multiple of a per-second rate (Hailuo 2.3 standard: $0.28 for 6 seconds against $0.56 for 10). Empty means clip length either does not change the rate or scales it linearly through the basis above.
          - `reference_images_priced_separately` boolean, required: Whether each reference image adds a flat charge on top of the per-second rate, billed independently of clip length and resolution. False means reference images cost nothing beyond the mode's main price.
          - `reference_images_included_before_surcharge` integer, required: How many reference images carry no separate input surcharge. Meaningful only when reference_images_priced_separately is true.
    - `model_params` PublicVideoModelParam[], required: The model-specific controls the model_params object accepts, with their validated envelopes. Keys not listed here are rejected before billing — never forwarded on the chance the provider accepts them.
      - `id` string, required: The model_params key.
      - `description` string, required
      - `type` string, required: JSON type of the value: string, integer, number, or boolean.
      - `allowed_values` string[], nullable, required: The exact legal values, where the control is an enum.
      - `minimum` number, nullable, required: Inclusive lower bound, where the control is numeric.
      - `maximum` number, nullable, required: Inclusive upper bound, where the control is numeric.
      - `max_length` integer, nullable, required: Maximum character count, where the control is a string and the provider publishes a limit.
      - `max_bytes` integer, nullable, required: Maximum UTF-8 encoded byte count for a string control; distinct from characters.
      - `modes` string[], nullable, required: The generation modes the control applies to; null means every mode the model supports.
  - `video_model_ids` string[], required: Deprecated: the same ids as video_models[].id. Kept one release for compatibility.
  - `audio_models` PublicAudioModelDescriptor[], required: Audio model capability descriptors, for generate-audio: which of the three modes each model serves, and per mode the duration envelope, the full preset-voice menu, the prompt-character ceiling, the sample limit, and how the cost is metered. No deprecated id alias here — video's exists only because its bare-id array shipped first.
    - `id` string, required: The registry id the generate-audio 'model' parameter validates against.
    - `label` string, required
    - `description` string, required: What the model is good at, relative to its registry siblings.
    - `modes` PublicAudioModelModes, required: The modes a model supports; an absent (null) mode is unsupported. Unlike the image and video lanes, the mode is STATED by the caller rather than derived from which inputs the request carries — every audio mode takes exactly text, so there is nothing to derive from.
      - `text_to_speech` PublicAudioModeCapability: One generation mode's real capability envelope for one model.
        - `duration_seconds` PublicAudioDuration, required: One mode's clip-length envelope, in whole seconds.
          - `min_seconds` integer, required: Shortest clip this mode can generate, in whole seconds.
          - `max_seconds` integer, required: Longest clip this mode can generate, in whole seconds.
          - `default` integer, required: The length that runs when duration_seconds is omitted.
          - `billing_floor_seconds` integer, nullable, required: A sample shorter than this bills as this many seconds. null means the provider publishes no floor and none is applied. Combined with num_samples this is multiplicative: four 5-second samples against a 10-second floor bill 40 seconds, not 20.
          - `billing_granularity_seconds` integer, nullable, required: Billing rounds UP to a whole multiple of this many seconds. null means it does not. Where a value is set the quoted per-second rate is charged on the rounded figure, so a 5-second ask against a 60-second granularity bills 60 seconds and 61 bills 120 — ask on the boundary.
          - `bills_measured_output` boolean, required: True when the charge meters the audio actually RETURNED rather than the duration requested, so duration_seconds is an upper bound for billing rather than the billed quantity. The charge never exceeds the estimate taken from the request.
        - `voices` string[], required: The preset voice names the voice parameter accepts, verbatim. Where a name carries a language tag ('Heitor (pt)'), the bare name ('Heitor') is accepted too when it names exactly one preset; a tag for a different language is rejected. Empty means one of two things, and voice_is_free_form tells you which: with it false, the mode has no voice axis and passing voice is rejected; with it true, the mode does take a voice but the provider publishes no roster to list.
        - `voice_is_free_form` boolean, required: True when voice accepts any provider voice name or cloned-voice id rather than a value from voices — the provider enumerates no roster, so only the shape is checked here and an unusable name fails at the provider. False on every mode with a preset roster, and on every mode with no voice axis at all.
        - `default_voice` string, nullable, required: The voice used when voice is omitted; null when the mode has no voice axis, and also null when voice_is_free_form is true and the provider's own default is whatever it applies.
        - `max_prompt_chars` integer, nullable, required: The provider's documented ceiling on the prompt, in characters. A longer prompt is rejected before anything is generated or billed. null means no ceiling has been established for this mode — not that it has none.
        - `max_samples` integer, required: How many distinct takes one call may render. 1 means the mode has no sample axis and num_samples above 1 is rejected. Every sample is billed.
        - `output_mime_types` string[], required: The audio container(s) this mode's output can arrive in.
        - `billing` PublicAudioModeBilling, required: How this mode's provider cost is metered. Exact credit amounts are computed from the resolved request at the team's credit rate, so this reports the basis and the knobs that move it rather than a flat price.
          - `basis` string, required: The quantity the price is quoted in: 'character' bills per character of the prompt text (speech — nothing knows how long the clip will be until it exists); 'utf8_byte' bills per UTF-8 byte of the prompt text (Fish Audio speech, so non-Latin scripts cost more per character); 'second' bills per second of generated audio, multiplied by num_samples and raised to duration_seconds.billing_floor_seconds where one is declared.
      - `text_to_music` PublicAudioModeCapability: One generation mode's real capability envelope for one model.
        - `duration_seconds` PublicAudioDuration, required: One mode's clip-length envelope, in whole seconds.
          - `min_seconds` integer, required: Shortest clip this mode can generate, in whole seconds.
          - `max_seconds` integer, required: Longest clip this mode can generate, in whole seconds.
          - `default` integer, required: The length that runs when duration_seconds is omitted.
          - `billing_floor_seconds` integer, nullable, required: A sample shorter than this bills as this many seconds. null means the provider publishes no floor and none is applied. Combined with num_samples this is multiplicative: four 5-second samples against a 10-second floor bill 40 seconds, not 20.
          - `billing_granularity_seconds` integer, nullable, required: Billing rounds UP to a whole multiple of this many seconds. null means it does not. Where a value is set the quoted per-second rate is charged on the rounded figure, so a 5-second ask against a 60-second granularity bills 60 seconds and 61 bills 120 — ask on the boundary.
          - `bills_measured_output` boolean, required: True when the charge meters the audio actually RETURNED rather than the duration requested, so duration_seconds is an upper bound for billing rather than the billed quantity. The charge never exceeds the estimate taken from the request.
        - `voices` string[], required: The preset voice names the voice parameter accepts, verbatim. Where a name carries a language tag ('Heitor (pt)'), the bare name ('Heitor') is accepted too when it names exactly one preset; a tag for a different language is rejected. Empty means one of two things, and voice_is_free_form tells you which: with it false, the mode has no voice axis and passing voice is rejected; with it true, the mode does take a voice but the provider publishes no roster to list.
        - `voice_is_free_form` boolean, required: True when voice accepts any provider voice name or cloned-voice id rather than a value from voices — the provider enumerates no roster, so only the shape is checked here and an unusable name fails at the provider. False on every mode with a preset roster, and on every mode with no voice axis at all.
        - `default_voice` string, nullable, required: The voice used when voice is omitted; null when the mode has no voice axis, and also null when voice_is_free_form is true and the provider's own default is whatever it applies.
        - `max_prompt_chars` integer, nullable, required: The provider's documented ceiling on the prompt, in characters. A longer prompt is rejected before anything is generated or billed. null means no ceiling has been established for this mode — not that it has none.
        - `max_samples` integer, required: How many distinct takes one call may render. 1 means the mode has no sample axis and num_samples above 1 is rejected. Every sample is billed.
        - `output_mime_types` string[], required: The audio container(s) this mode's output can arrive in.
        - `billing` PublicAudioModeBilling, required: How this mode's provider cost is metered. Exact credit amounts are computed from the resolved request at the team's credit rate, so this reports the basis and the knobs that move it rather than a flat price.
          - `basis` string, required: The quantity the price is quoted in: 'character' bills per character of the prompt text (speech — nothing knows how long the clip will be until it exists); 'utf8_byte' bills per UTF-8 byte of the prompt text (Fish Audio speech, so non-Latin scripts cost more per character); 'second' bills per second of generated audio, multiplied by num_samples and raised to duration_seconds.billing_floor_seconds where one is declared.
      - `text_to_sfx` PublicAudioModeCapability: One generation mode's real capability envelope for one model.
        - `duration_seconds` PublicAudioDuration, required: One mode's clip-length envelope, in whole seconds.
          - `min_seconds` integer, required: Shortest clip this mode can generate, in whole seconds.
          - `max_seconds` integer, required: Longest clip this mode can generate, in whole seconds.
          - `default` integer, required: The length that runs when duration_seconds is omitted.
          - `billing_floor_seconds` integer, nullable, required: A sample shorter than this bills as this many seconds. null means the provider publishes no floor and none is applied. Combined with num_samples this is multiplicative: four 5-second samples against a 10-second floor bill 40 seconds, not 20.
          - `billing_granularity_seconds` integer, nullable, required: Billing rounds UP to a whole multiple of this many seconds. null means it does not. Where a value is set the quoted per-second rate is charged on the rounded figure, so a 5-second ask against a 60-second granularity bills 60 seconds and 61 bills 120 — ask on the boundary.
          - `bills_measured_output` boolean, required: True when the charge meters the audio actually RETURNED rather than the duration requested, so duration_seconds is an upper bound for billing rather than the billed quantity. The charge never exceeds the estimate taken from the request.
        - `voices` string[], required: The preset voice names the voice parameter accepts, verbatim. Where a name carries a language tag ('Heitor (pt)'), the bare name ('Heitor') is accepted too when it names exactly one preset; a tag for a different language is rejected. Empty means one of two things, and voice_is_free_form tells you which: with it false, the mode has no voice axis and passing voice is rejected; with it true, the mode does take a voice but the provider publishes no roster to list.
        - `voice_is_free_form` boolean, required: True when voice accepts any provider voice name or cloned-voice id rather than a value from voices — the provider enumerates no roster, so only the shape is checked here and an unusable name fails at the provider. False on every mode with a preset roster, and on every mode with no voice axis at all.
        - `default_voice` string, nullable, required: The voice used when voice is omitted; null when the mode has no voice axis, and also null when voice_is_free_form is true and the provider's own default is whatever it applies.
        - `max_prompt_chars` integer, nullable, required: The provider's documented ceiling on the prompt, in characters. A longer prompt is rejected before anything is generated or billed. null means no ceiling has been established for this mode — not that it has none.
        - `max_samples` integer, required: How many distinct takes one call may render. 1 means the mode has no sample axis and num_samples above 1 is rejected. Every sample is billed.
        - `output_mime_types` string[], required: The audio container(s) this mode's output can arrive in.
        - `billing` PublicAudioModeBilling, required: How this mode's provider cost is metered. Exact credit amounts are computed from the resolved request at the team's credit rate, so this reports the basis and the knobs that move it rather than a flat price.
          - `basis` string, required: The quantity the price is quoted in: 'character' bills per character of the prompt text (speech — nothing knows how long the clip will be until it exists); 'utf8_byte' bills per UTF-8 byte of the prompt text (Fish Audio speech, so non-Latin scripts cost more per character); 'second' bills per second of generated audio, multiplied by num_samples and raised to duration_seconds.billing_floor_seconds where one is declared.
    - `model_params` PublicAudioModelParam[], required: The model-specific controls the model_params object accepts, with their validated envelopes. Keys not listed here are rejected before billing — never forwarded on the chance the provider accepts them.
      - `id` string, required: The model_params key.
      - `description` string, required
      - `type` string, required: JSON type of the value: string, integer, number, or boolean.
      - `allowed_values` string[], nullable, required: The exact legal values, where the control is a string enum.
      - `allowed_integers` integer[], nullable, required: The exact legal values, where the control is an integer enum (for example a sample rate).
      - `minimum` number, nullable, required: Inclusive lower bound, where the control is numeric.
      - `maximum` number, nullable, required: Inclusive upper bound, where the control is numeric.
      - `default` union, required: The provider default when this control is omitted, where Moda publishes one; null means no default metadata is available in this registry.
        - string
        - integer
        - number
        - boolean
      - `max_length` integer, nullable, required: Maximum character count, where the control is a string and the provider publishes a limit.
      - `modes` string[], nullable, required: The generation modes the control applies to; null means every mode the model supports.
    - `price_per_1k_usd` number: The current customer price in USD per 1,000 characters, present on every model whose speech bills per character (billing basis 'character') and absent on every other. During a promotion it is the promo price, charged for any request admitted before promo_until.
    - `list_price_per_1k_usd` number: Present only during a promotion: the standard price per 1,000 characters it returns to.
    - `promo_until` string, date-time: Present only during a promotion: the instant (ISO 8601, UTC) the promo price ends. A request admitted before it is charged the promo price; from it on the list price applies.
    - `promo_percent_off` integer: Present only during a promotion: the discount off the list price as the provider announces it.

## Other responses

- `401`: Authentication required.
- `402`: Insufficient credits for a metered operation.
- `403`: Permission denied for this scope.
- `404`: Resource not found.
- `409`: Conflict (idempotency / resource state).
- `422`: Request validation failed.
- `429`: Rate limit exceeded.
- `500`: Internal error.

## Changes

- **2026-11-03** `9ac6a3abc0f8`: 1 info
  - endpoint added

[Operation history](https://skmtc.dev/moda/apis/moda-public-api/changes/media/models/get.md)

---

[API](https://skmtc.dev/moda/apis/moda-public-api.md) - [All operations](https://skmtc.dev/moda/apis/moda-public-api/llms.txt) - [OpenAPI document](https://skmtc.dev/moda/apis/moda-public-api/revisions/9ac6a3abc0f8?raw)