Skip to content
Home Publishers Advertisers Solutions Resources About Contact Schedule a Call

Ad operations field guide

VAST Troubleshooting Guide

When a video ad does not render, the fastest route to an answer is a disciplined sequence—not a fresh tag and a second guess. This guide helps programmatic video and CTV teams isolate transport, XML, wrapper, creative, tracking, player and latency issues before running a controlled retest.

By AdSelect TeamTechnical resource
Diagnostic flow for checking VAST XML, wrapper chains, media delivery and tracking
A repeatable VAST investigation moves from request context to transport, document structure, wrapper resolution, creative delivery and event evidence.

Why the order of diagnosis matters

A VAST response can look valid in a browser and still fail in a real playback environment. The player may receive a different redirect path, reject a media type, run out of time, fail to expand a macro or behave differently when an SSAI service sits between the tag and the screen. If a team changes several variables at once, a successful retest proves little and a failed one produces more uncertainty.

Start with one reproducible request and preserve every artifact. Follow the same wrapper chain the affected environment followed, record each status and timing, and compare declared metadata with what the player actually supports. That creates a shared fact pattern for the supply partner, demand partner, ad server, player and measurement teams.

Fast triage

Start with the observed failure, not the assumed cause

VAST symptoms and the evidence to collect first
Observed symptomCollect firstNext branch
No ad responseInitial URL, status, headers, response bodyTransport, consent or request inputs
Wrapper resolves but video does not startComplete chain and final InLine responseMedia compatibility and player logs
Starts, then stalls or exitsMedia fetch, duration and playback eventsCreative delivery, bitrate or timeout
Plays, but reporting differsEvent timestamps and tracking requestsMacro expansion, deduplication or SSAI logic

Step 01

Reproduce the failure with its full context

Record the exact tag or request that failed, when it ran, and where it ran. Include app or site identity, device or user-agent context, operating system, player or SDK version, geography, connection type, consent state, ad position, pod position and whether playback was client-side or server-side. Preserve any request identifiers that allow the parties to correlate logs without exposing personal data.

Do not begin with an edited URL copied from a dashboard. A manually opened tag can follow a different network path and may omit headers, macros or privacy signals that were present—or missing—in production. If the problem is intermittent, collect a successful example from the same environment as well. The comparison often reveals a changing wrapper, creative selection, redirect host or request field.

Step 02

Verify HTTP, HTTPS and every redirect

Fetch the original URL from a network path that resembles the affected environment. Record the HTTP status, content type, response size, connection timing and final destination. Confirm that TLS succeeds and that a secure page or app is not asked to retrieve insecure resources. Look for authentication requirements, geo restrictions, consent-dependent responses, DNS differences and redirect loops.

Follow each VAST Wrapper URI separately instead of treating the chain as one opaque call. A browser may tolerate behavior that a television app, SDK or stitcher rejects. It may also apply cookies or headers the real device never sends. Note redirects introduced by the HTTP layer as well as wrappers declared inside VAST. Any hop that returns HTML, a block page, an empty response or an unexpected MIME type should be investigated before moving deeper into the document.

Step 03

Validate the XML before interpreting it

Save the raw response and validate it as XML. Check the declaration and encoding, the VAST root element, declared version, namespace usage where applicable, and the placement of each Ad element. Confirm that special characters in URLs are escaped correctly or protected in CDATA where the implementation expects it. A single unescaped ampersand can make an otherwise familiar tag unreadable to an XML parser.

Then distinguish a structurally valid document from a semantically useful one. The required information for the selected delivery path must exist, URLs must be usable, identifiers should be stable enough for investigation, and values should use formats the receiver understands. Compare the response against the specification associated with its declared version, but also check the receiving platform’s documented support. Validation against a schema is evidence of structure; it is not proof that a particular player can render the creative.

Step 04

Map the InLine and Wrapper chain

Identify whether each Ad contains an InLine response or a Wrapper that points onward. Draw the chain in order and keep the response from every hop. For wrappers, record the next VAST URI, impressions, errors, tracking events and any creative-level additions that need to be combined with the final InLine response. Confirm whether the player or SSAI service actually follows the same chain you mapped.

There is no useful universal answer to “how many wrappers are safe” without the playback environment and timeout policy. Every hop consumes network and processing time, and platforms can impose their own limits. A chain can also terminate early because one endpoint times out, returns no eligible ad, sends invalid XML or selects a creative the receiver cannot use. Capture the terminal response and the last successful hop; otherwise partners may debug different versions of the path.

Map

One row per wrapper, including host and timing.

Merge

Track events and errors contributed across the chain.

Resolve

Preserve the final InLine document and selected creative.

Step 05

Inspect media files as the player sees them

List every candidate media file and compare its delivery method, MIME type, codec information, bitrate, width, height and URL with the player’s documented capabilities. Confirm which file the player selected; the presence of one compatible option does not mean it was chosen. Retrieve that exact URL from the relevant environment and capture status, content type, content length, redirect behavior and time to first byte.

For progressive files, check that the asset is reachable and encoded for the intended devices. For streaming assets, inspect the manifest and the referenced segments, not only the top-level URL. On CTV, screen size can make creative resolution and quality selection more visible, but a larger file also has delivery and startup implications. The 2024 CTV addendum is a useful standards reference; final acceptance still depends on the application, player, device class and commercial test requirements.

Keep creative quality and technical compatibility separate. A file can play but still be unsuitable for a placement, and a high-quality asset can fail because its codec or delivery method is unsupported. Record both findings so a creative replacement does not hide a player configuration issue.

Step 06

Compare duration, skippability and placement rules

Compare the duration declared in VAST with the media duration and the slot or pod constraints. Confirm whether the placement accepts the creative length and whether the player rounds, caps or rejects unexpected values. In a pod, check the position and the time budget available for the full break, not only one ad.

Where skippability applies, inspect the declared skip offset and the receiving platform’s support. A time value and a percentage may not be handled identically by every implementation. Also verify that the commercial setup matches the playback behavior: a skippable creative in a non-skippable placement—or the reverse—can create reporting and user-experience disputes even when the media renders. For CTV, do not assume a desktop interaction pattern or skip control exists; confirm the remote-control and player behavior for that environment.

Step 07

Test macros, URL encoding and escaping

Inventory the macros used in the tag and tracking URLs, then record which system is responsible for replacing each one. Examine the final emitted URL—not only the template stored in the ad server. Confirm that cache-busting, error, playhead, asset and privacy-related values are expanded in the expected format and at the correct point in the chain.

Encoding errors commonly appear when one system encodes an already encoded value or when characters required by XML are left unescaped. Keep three artifacts when possible: the XML as received, the URL before the request is sent, and the actual network request. That makes it possible to distinguish an XML parsing problem from a macro substitution problem or a destination-side parsing problem. Redact tokens and personal data before sharing, but preserve parameter names, ordering where relevant, and enough structure for another team to reproduce the behavior.

Step 08

Reconcile tracking and error evidence

Create a timeline for the impression and playback lifecycle. Record which system emitted the impression, start, quartile, complete, click and any other relevant events; the corresponding endpoint; request time; response; and retry behavior. Then compare those events with the player state. A received VAST response is not the same as a rendered impression, and a media fetch is not the same as a completed view.

Collect VAST error callbacks from wrappers and the final InLine response, including the expanded error information when available. Do not rely on one dashboard total to identify the source of a discrepancy. Differences can come from event definitions, deduplication, sampling, retries, blocked requests, clock boundaries, time zones or one party counting an earlier stage of delivery. Use request-level examples first, agree on the event being compared, and only then examine aggregate variance.

Step 09

Separate player behavior from SSAI behavior

Determine which component resolves wrappers, selects media, fires tracking and reports errors. In client-side playback, the app or player may perform most of that work. In server-side ad insertion, an ad decisioning service or stitcher may retrieve and prepare the creative before the device receives a stream. The same VAST response can therefore produce different evidence and constraints across the two paths.

For SSAI, compare the ad decision request, wrapper-resolution logs, creative-conditioning outcome, stitched manifest and beaconing model. Confirm whether tracking is client-fired, server-fired or divided between components. For client-side playback, capture the player state transition, console or SDK errors, network calls and selected creative. Avoid testing an SSAI failure only in a browser tag validator; a validator can help with document structure, but it does not reproduce the full stitching and playback path.

If one player succeeds and another fails, treat the successful result as a comparison case—not proof that the failing platform is defective. Compare supported VAST features, media capabilities, timeout budgets, security policies and macro responsibilities before assigning ownership.

Step 10

Budget latency across the entire path

Measure DNS, connection, TLS, server response and download time for the first tag, every HTTP redirect, each wrapper, the final InLine response and the selected media or manifest. Compare the total with the player or SSAI service’s actual deadline. An individual hop can look acceptable while the combined chain misses the playback budget.

Run measurements from the affected geography and device network where possible. A test from a nearby data centre can hide last-mile conditions, regional routing or device DNS behavior. Check whether endpoints respond differently without cookies, with limited headers, or from residential and connected-device environments. When optimizing, remove or repair the specific slow hop, then repeat the same measurement. Increasing a timeout may mask the symptom while making startup or ad-break behavior worse for viewers.

Step 11

Run a controlled retest

State the suspected failure and the one change intended to address it. Hold the inventory source, player or SSAI path, geography, placement and measurement window as constant as practical. Use a small, defined traffic scope and agree on the expected observable result before starting. If a media replacement is the change, keep the tag path stable. If a wrapper is removed, keep the creative stable.

Collect the same artifacts as the original reproduction and compare them side by side. A retest is successful only when the expected technical event occurs in the intended environment and the parties can explain why. Do not scale from one clean request alone. Review enough controlled examples to establish that the failure condition has changed and that new issues—such as lost tracking or altered creative selection—were not introduced.

For an AdSelect partnership, the controlled-test scope is agreed source by source. The VAST integration process explains the information aligned before a tag test, while the inventory quality approach explains how available evidence is tied to the specific source and review period.

Step 12

Send a handoff packet another team can use

A useful escalation should let the recipient reproduce the failure without asking for the basics again. Start with a one-sentence impact statement and a one-sentence expected behavior. Add the timestamp and time zone, environment, app or site, placement, playback path, affected geography and approximate frequency. Include safe request identifiers for log correlation.

Attach the evidence

  • • Original request and headers after safe redaction
  • • Every wrapper and the final InLine response
  • • HTTP statuses, timings and redirect destinations
  • • Selected media or manifest details
  • • Player, SDK or SSAI logs around the failure
  • • Tracking calls and error callbacks

State the decision needed

  • • Suspected failing component and why
  • • Facts confirmed versus assumptions still open
  • • One proposed change for the retest
  • • Test scope, owner and timing
  • • Expected result and stop condition
  • • Contacts for ad server, player and partner teams

Remove credentials, personal data and unnecessary commercial information before sharing. If a URL contains a live token, replace the secret while preserving enough structure to show the parameters and macro behavior. Name files by hop and timestamp so the sequence remains clear when the packet moves across organizations.

Programmatic video context

See how video opportunities are scoped across placement, creative, integration, market and reporting requirements.

Explore programmatic video →

CTV partnership context

Review app, device, placement, supply-path and test details relevant to connected TV opportunities.

Explore CTV advertising →

More AdSelect resources

Continue with practical guides for OpenRTB readiness and supply-path transparency.

Browse all resources →

Plan a controlled test

Bring the VAST path, context and evidence.

Tell the AdSelect Team whether you are bringing supply or demand, the video or CTV environment involved, the integration path, target markets and the issue or opportunity you want to evaluate.

Schedule a Partnership Call