Microsoft AI-901: Content Understanding — Documents, Images, Audio and Video

A generative model may produce an eloquent answer about a document while missing the one field a business needs. An invoice total can be confused with a balance carried forward. A recording can be transcribed without identifying the correct speaker. A video summary can overlook the moment an event actually happened. These are not simply prompting problems: they are problems of extracting faithful, structured evidence from information that comes in several formats.

For the current AI-901 Azure AI Fundamentals exam, Microsoft explicitly includes Azure Content Understanding in Foundry Tools. Candidates should recognize how documents, forms, images, audio and video can be analyzed, and how a lightweight application submits content and interprets the returned results. This walkthrough addresses that implementation gap without repeating the model-selection, vision or speech basics already covered elsewhere on Exam-Topics.net.

The examples use Microsoft’s generally available Content Understanding REST API version 2025-11-01 for ordinary prebuilt analyzers. A newer 2026-06-01-preview version has additional features, but preview APIs are not the safe default for production. Check the current documentation and the resource’s supported models before running a lab because deployments, available analyzers, model defaults and regions can change.

Start by defining the output the business actually needs

Consider a small customer-support operation receiving PDF invoices, photographs of damaged items, recorded customer calls and short delivery videos. A manager asks for one searchable case record. Treating these four inputs as interchangeable blobs is a design mistake: a PDF may contain important table relationships, a photograph may need visual interpretation, a recording needs transcript and speaker context, and a video may require timing and keyframes. The desired output should be defined separately for each.

For invoices, the output might include invoice identifier, date, currency, line items and amount due. For images, it might be a description of visible damage and the items involved. For audio, the business may need a transcript, useful summary and speaker labels; for video, a summary with relevant keyframes or timestamps. A single interface can orchestrate these tasks, but each modality demands an extraction and validation strategy appropriate to its evidence.

It helps to separate extraction from generation. An extractor should preserve source facts. A later language model can explain those facts or draft a response, but its fluent wording is not a substitute for an exact field value. A useful AI-901 scenario may describe a solution that looks impressive in a chat demo yet fails an accounting or compliance requirement because it cannot show where a number originated.

Prepare a Content Understanding resource and a safe sample

Use an authorized Azure subscription and a Microsoft Foundry resource in a region that supports Content Understanding. Configure the required model deployments and defaults for the analyzer you intend to use; the particular defaults may depend on modality and service version. Microsoft supplies a Content Understanding Studio experience as well as REST and SDK interfaces. For a first lab, Studio can help you inspect the available prebuilt analyzers before writing code.

Practice with synthetic or publicly authorized files only. An invoice sample should contain fictitious names and account details. An image should not reveal a real customer’s address or identity. An audio recording should be a brief sample for which the speakers have agreed to the use. Uploading private production material into a quickstart can create unnecessary storage, access and retention risks, even if a technical tutorial succeeds.

You also need a permitted way to supply the source. Microsoft’s REST quickstart accepts a URL in its inputs array for common analyzers. In a private workflow, this could be an appropriately scoped Azure Storage URL rather than an unrestricted public document. Protect any temporary access token, give it an appropriate lifetime and ensure that the resource can reach the source. An HTTP success code from a storage endpoint does not prove the file is suitable or correctly classified for AI processing.

Understanding Microsoft Foundry services helps distinguish Content Understanding from model chat, vision interpretation and speech tools. You do not have to use every tool in one workflow; use Content Understanding when structured information extraction from mixed media is what the problem actually requires.

Submit a document and understand the asynchronous result

A useful first request analyzes a fictitious invoice with the prebuilt invoice analyzer. In the generally available REST API, the application submits an analysis request to the Content Understanding endpoint. A successful submission commonly returns HTTP 202 Accepted and an Operation-Location header. That is a promise that the service accepted an operation, not evidence that the final fields have already been extracted.

The following skeleton is deliberately parameterized. Replace the endpoint, key and sample URL with authorized values from your own Foundry resource and storage. Do not paste secrets into a published notebook or a site article. The API version and analyzer route reflect Microsoft’s current generally available quickstart rather than the preview-only agentic analysis workflow.

curl -i -X POST   "{ENDPOINT}/contentunderstanding/analyzers/prebuilt-invoice:analyze?api-version=2025-11-01"   -H "Ocp-Apim-Subscription-Key: {KEY}"   -H "Content-Type: application/json"   -d '{
    "inputs": [
      { "url": "{AUTHORIZED_INVOICE_URL}" }
    ]
  }'

Copy the Operation-Location response value returned by your service and use it to check the analysis status. Do not invent a result URL by changing the request path; the response supplies the correct operation identifier and location. A status such as NotStarted or Running means that the work is not finished. Only process the fields once the status is Succeeded, and handle terminal failure states without silently turning errors into empty data.

curl -i -X GET "{OPERATION_LOCATION}"   -H "Ocp-Apim-Subscription-Key: {KEY}"

The returned data is structured. An invoice analyzer can expose fields containing string, number, date or object values, along with location/provenance or confidence information. Applications should not assume every expected property is populated or that a confidence score makes a value unquestionably correct. Inspect the returned field shape, check required values and compare them with the actual invoice. If an invoice contains a subtotal, tax, prior balance and amount due, validate which one belongs in the target field.

This is the essential light application loop for AI-901: submit a supported input, record operation identity, wait for completion, read structured output and validate what matters. The same pattern generalizes to other modalities. It is not necessary to build a distributed processing service merely to demonstrate the skill at fundamentals level.

Documents and forms: preserve relationships, not only words

Document understanding becomes difficult when meaning depends on layout. A receipt may contain a total at the bottom, while an invoice can include multiple currency amounts on different pages. A purchase order can contain line-item rows and shipping terms whose relative positions matter. Extracting the text is only the first step; the application must preserve which value belongs to which label and whether it refers to a line item or the entire document.

When testing an analyzer, choose a few fields with known expected results: a document ID, date and one monetary amount. Look for a field name that matches the business definition rather than the most plausible number in the result. If the service does not find the invoice date because the document is rotated or blurred, mark the field uncertain and route it for review. Do not substitute today’s date or ask a general model to guess what the source probably intended.

A table adds another risk. A row may contain quantity, price and tax, while a column heading is several lines above the values. If preprocessing or extraction drops the heading, a downstream program may treat a unit price as an extended line total. Review the field-level evidence and, for important cases, compare calculated totals with the reported total. The objective is traceable extraction rather than attractive formatting alone.

For AI-901, this is the bridge from older optical-character-recognition concepts to a modern Foundry workflow. The vision and multimodal interpretation material explains how models understand visual inputs; Content Understanding extends that question to structured fields and evidence that a business can actually use.

Images, audio and video demand different validation

An image analyzer may describe a scene, identify relevant content or produce search-oriented metadata. The result can be useful for classifying an incoming photo or preparing a summary, but it cannot establish facts that are not visible. A photograph of damaged packaging may show a dented corner; it cannot prove when the damage occurred or who caused it. Keep observed evidence distinct from inferred explanation.

Audio introduces recognition accuracy and speaker boundaries. A transcript may identify that a customer said “fifteen” or “fifty,” but recording quality can make the distinction uncertain. If an account ID or monetary value drives a downstream operation, require additional confirmation. Speaker labeling also matters: a support representative explaining a policy should not be mistaken for the customer accepting it. A useful application preserves uncertain spans for review.

Video introduces time. A summary saying “the package was dropped” is not a complete audit trail if the video shows multiple handling events. Keyframes, transcript segments and timestamps can help identify when an event occurred and what evidence supports the summary. Frame selection can miss short incidents; a test set must include examples where the important event is brief or visually ambiguous.

Microsoft documents prebuilt examples for images, audio and video as well as invoices. The route pattern stays recognizable while the analyzer name and expected output change. Do not assume all output fields or latency characteristics are identical across analyzers. A document’s exact invoice fields, an image description, an audio transcript and a video’s keyframe references need different downstream checks. The language and speech differences are particularly useful before interpreting transcript and spoken-prompt scenarios.

Turn the service call into a useful small application

A beginner application can be a command-line program with a clear sequence: accept an authorized input URL, choose the analyzer for the source type, submit the analysis, store the returned operation location, poll cautiously for completion, validate required fields and print a structured result or an actionable error. This exercises the current AI-901 implementation objective without unnecessary cloud orchestration.

Use a finite polling policy. The service may need time to process a file, but the application should not retry indefinitely or send duplicate analyze requests each time a result is not ready. Distinguish a polling GET from a new analysis POST. A failure might require fixing an unsupported file, a missing model default, a permissions problem or a regional availability issue. Retry only when it is appropriate and make repeated requests observable.

When the analysis succeeds, validate results before writing them to another system. If an invoice ID is missing, mark the record incomplete. If the amount is uncertain, require a human to compare it with the invoice. If a video timestamp is absent, do not claim a specific event time. Treat source identity, analyzer version and field-level evidence as part of the output. These controls prevent a technically successful extraction from becoming an incorrect business action.

Logging should make an incident explainable while protecting sensitive data. Record operation IDs, source versions, duration, status and field-validation results; avoid writing raw customer documents, full private transcripts or service keys into application logs. Restrict who can inspect the stored results and decide how long samples should be retained. The AI security and governance principles still apply when the output is structured JSON rather than fluent text.

Use failure cases to prepare for AI-901 scenarios

Start with one clean invoice and one deliberately difficult document. A clean request should return the expected field. A blurred or incomplete request should cause the application to expose missing or uncertain fields rather than invent replacements. Then try a short audio sample with an ambiguous number, an image that shows only part of an object and a video where context spans several seconds. Ask what the result actually proves and what remains unknown.

A scenario that says “read a form and populate exact fields” suggests structured information extraction, not ordinary chat. A scenario that says “describe a photograph” may need image interpretation without field-level extraction. A scenario that asks for a new image requires generation, not analysis of an existing picture. Those distinctions are foundational, but adding the small submit-poll-validate application makes them much harder to confuse.

To complete the lab, produce a short comparison of the original source and returned structured output, including a field that you deliberately rejected. Explain which endpoint and resource processed the file, where authorization was enforced, and why the next application step was allowed or blocked. That explanation is stronger evidence of AI-901 readiness than copying a successful sample response without understanding it.

Content Understanding is not a substitute for sound application design. It provides machine-readable evidence from mixed media; the surrounding system must decide whether the evidence is accurate, permitted and sufficient for a decision. The most useful AI-901 preparation is learning that boundary and testing it with small examples before a production workflow depends on it.