TwelveLabs Pegasus 1.5 on Amazon Bedrock: Video Understanding API, Timestamped Segments, Limits, Pricing, and Pegasus vs Marengo

TwelveLabs Pegasus 1.5 is a video language model, now available in Amazon Bedrock, that watches a video and answers in text: summaries, answers to questions, and, new in 1.5, timestamped segments returned as JSON (every goal in a match, every topic change in a news broadcast, every scene with a product on screen). It takes videos up to 2 hours long (double Pegasus 1.2's 1 hour), up to 2 GB from Amazon S3 or 25 MB sent inline as base64, and up to 30 reference images per request, with no indexing step first. In Bedrock its model ID is twelvelabs.pegasus-1-5-v1:0, available in US West (Oregon), with global. and us. cross-Region inference profiles; you call it with InvokeModel or the streaming version. It is billed through AWS Marketplace, metered by input video seconds and output tokens, so charges show under TwelveLabs on your AWS bill. Its sibling, Marengo, does something different: it turns video into embeddings for search. Below: what Pegasus 1.5 can do, a working Python call, the time-based metadata mode, every limit, cost, Pegasus vs Marengo, and the errors you are likely to hit.

The shop records its how-to videos for customers, and over two years they had built up hours of footage nobody could search. Jake's question was simple: "Which video shows how to reset the router?" Answering it meant watching. Ethan pointed Pegasus 1.5 at one of the longer recordings with a plain request: list every section where a device is being reset, with start and end times. The answer came back as a short JSON list with timestamps. It was the first time anyone had searched the shop's videos without pressing play.

New to Amazon Bedrock? The cards below cover Bedrock pricing, inference profiles and how Bedrock compares with Google's platform.

What Pegasus 1.5 does

TwelveLabs builds models that understand video the way a person watching it would: what is on screen, what is said, what text appears, and when each thing happens. Pegasus is their generative model; you give it a video and an instruction, and it writes the answer. It understands the visual track, the audio and on-screen text together, so "when does the presenter mention the warranty?" works even if the word only appears in speech.

What Pegasus 1.5 adds over 1.2:

• Time-based metadata: describe the moments you care about (for example "a goal is scored" or "a product is shown close up"), and it returns each matching segment with start and end times and the fields you asked for, as JSON.
• Reference images: include up to 30 images with the request, such as a logo or a person's photo, and ask about where they appear.
• No ingestion step: the video is processed on the fly; you do not upload it to an index first.
• Video segmentation across the whole timeline.
• Longer videos: up to 2 hours per request, from 1 hour.

It keeps what earlier versions did: summaries, open questions about the content, reading objects, numbers and on-screen text, and finding when things happen. English has full support; Arabic, Chinese, French, German, Italian, Japanese, Korean, Portuguese, Russian, Spanish, Thai and Vietnamese have partial support.

Jake: "So it doesn't just describe the video, it tells you where in the video?"

Ethan: "That's the new part. Start time, end time, and whatever details you asked for, for every match."

Calling Pegasus 1.5 from Python

Getting from nothing to a first answer takes four steps:

1. Upload the video to an S3 bucket in US West (Oregon), the Region where the model runs.
2. Check permissions: your user or role needs bedrock:InvokeModel and read access to that object (details below).
3. Install or update boto3 (pip install -U boto3), so the client knows the current Bedrock runtime API.
4. Send one request with the video's location and your instruction:

import json
import boto3
from botocore.config import Config

# Long videos take a while: give the client a long read timeout
brt = boto3.client("bedrock-runtime", region_name="us-west-2",
                   config=Config(read_timeout=900))

body = {
    "inputPrompt": "Summarize this video in five bullet points, then list the products shown.",
    "mediaSource": {
        "s3Location": {
            "uri": "s3://shop-videos/howto/router-reset.mp4",
            "bucketOwner": "111122223333"
        }
    },
    "temperature": 0.2,
    "maxOutputTokens": 2048
}

resp = brt.invoke_model(
    modelId="global.twelvelabs.pegasus-1-5-v1:0",
    body=json.JSONEncoder().encode(body),
    contentType="application/json",
    accept="application/json",
)
result = json.loads(resp["body"].read())
print(result["message"])

A few details that matter:

• Model ID or profile: twelvelabs.pegasus-1-5-v1:0 calls the model in its Region; global.twelvelabs.pegasus-1-5-v1:0 uses the global cross-Region profile, and us. keeps processing within US Regions. If you see "on-demand throughput isn't supported", use a profile ID; our guide to that error explains why.
• Inline video: instead of s3Location, send "base64String": "..." for files up to 25 MB.
• Streaming: invoke_model_with_response_stream returns the answer in chunks as it is written, useful for long summaries; our Bedrock streaming guide shows how to read the stream.
• Usage: the response includes token counts and a stop reason; add "includeMetering": true to also get the billed video seconds.

The request fields at a glance:

Time-based metadata: timestamped segments as JSON

This is the feature that makes 1.5 worth a look for archives. Set analysisMode to time_based_metadata and describe, in responseFormat, the kinds of segment you want. Each segment definition has:

• an id, such as device_reset, which comes back on each match so you know which definition it fits;
• a description in plain words: "the presenter resets a router or modem";
• fields you want filled in for each match, each with a name, a type and a description, for example device_model (string) or steps_shown (number);
• a time format for the start and end: seconds, hh:mm:ss or hh:mm:ss.fff.

The answer is a segments list: for every match, the start and end time, your fields, and the definition id it matched, plus a definition_errors list if any definition could not be applied. Long videos in this mode can take minutes, which is why the example sets a 900-second read timeout.

Practical tips for good segments:

1. Describe what is visible or audible, not what you hope it means: "a person points at a red error light" works better than "a troubleshooting moment".
2. Keep fields few and concrete; three well-described fields beat ten vague ones.
3. Use several definitions in one call rather than one call per definition, since the video is processed once.
4. Test on a short clip first, check the timestamps by eye, then run your archive.
5. Store the JSON with the video's S3 key, so your website or search tool can jump straight to each segment.

Jake: "So I could get a list of every router reset across all our videos?"

Ethan: "One call per video, the same definitions each time, and the results go into a table we can search."

Pegasus 1.5 limits

Videos longer than 2 hours or bigger than 2 GB need splitting first (FFmpeg can cut by time without re-encoding), and you then adjust the timestamps of later parts by each part's start offset.

Access, permissions and API keys

• IAM permissions: bedrock:InvokeModel and bedrock:InvokeModelWithResponseStream on the model or inference profile, plus s3:GetObject on the video, for the identity that calls it.
• Bedrock API keys also work: set the key in AWS_BEARER_TOKEN_BEDROCK; the key's identity needs bedrock:CallWithBearerToken too.
• Marketplace subscription: Pegasus is a third-party model sold through AWS Marketplace, so the first use in an account involves a Marketplace subscription, and whoever triggers it needs the Marketplace subscribe permissions; afterwards ordinary Bedrock permissions are enough.
• Cost tracking per project: create an application inference profile for the model and call it by ARN; our application inference profile guide covers tagging and budgets.

What Pegasus 1.5 costs

Pegasus 1.5 is billed through AWS Marketplace, so its charges appear on your normal AWS bill, and in Cost Explorer, under TwelveLabs rather than Amazon Bedrock. Usage is metered by the seconds of video you send and the output tokens it writes; the current rates are on the Bedrock pricing page under TwelveLabs. Some practical points:

• Video length drives the bill, so trim intros, outros and dead air before sending, and use segment definitions to get several answers from one pass rather than calling once per question.
• Set includeMetering on test runs to see exactly how many video seconds and output tokens each kind of request uses, then multiply by your archive size before committing.
• S3 storage for the videos is billed separately, as usual.

Our Bedrock pricing guide covers the other Bedrock cost levers, from batch jobs to caching.

Pegasus vs Marengo

TwelveLabs has two model families, and they do different jobs:

• Pegasus is generative: it reads a video and writes text (summaries, answers, timestamped segments). You ask; it answers about one video at a time.
• Marengo is an embedding model: it turns video, audio, images and text into vectors, so you can search a large library by meaning ("scenes of a red car at night") and find matching clips across thousands of videos.

They work well together: Marengo finds the right videos or clips in a big archive; Pegasus then explains or extracts details from the ones you found. For a small archive where you already know which video to look at, Pegasus alone is enough. If you are building search over text instead of video, our Titan Text Embeddings guide covers the text side.

What people use it for

• News and broadcast archives: catalog every editorial segment, topic and speaker change, so producers can find footage in seconds.
• Sports: find plays and scoring moments to cut highlights automatically.
• Streaming apps: recommendations by moment rather than by title, ad placement that fits the scene, and segment-level brand-safety checks.
• Training and support videos, like the shop's: chapters, step lists and "jump to the part where" links generated from existing recordings.
• Compliance review: flag segments where a logo, a person or a sensitive topic appears, for a human to check.

For monitoring in production, Bedrock publishes the usual CloudWatch metrics for the model (invocations, output tokens, latency and client errors) in the AWS/Bedrock namespace.

Common errors with Pegasus on Bedrock

• AccessDeniedException: missing bedrock:InvokeModel on the model or profile ARN, or the Marketplace subscription step has not completed.
• "on-demand throughput isn't supported": call the global. or us. inference profile ID instead of the bare model ID.
• ValidationException about the media: the video is over 2 hours or 2 GB, the base64 payload is over 25 MB, or the resolution or aspect ratio is outside the limits.
• S3 access errors: the bucket owner account in the request is wrong, or the caller cannot read the object; keep the bucket in the same Region.
• Read timeout in your code: long videos, especially in time-based mode, take minutes; raise the client's read timeout (900 seconds in the example) or stream the response.
• ThrottlingException: too many concurrent requests; retry with backoff, or spread an archive job over time.

Frequently asked questions

The shop's video library now has chapters: a nightly job sends each new recording to Pegasus with the same three segment definitions (device resets, cable connections, and settings screens), stores the JSON beside the video, and the support page now has "jump to" links. Jake no longer answers "which video shows..." by watching. Ethan's rule for the project: test every new definition on one short clip first, because a vague description returns vague segments.

Revision note. Written October 19, 2026, the day Pegasus 1.5 arrived in Amazon Bedrock. We will add dated updates as Regions and prices change.