DEV Community: Mixpeek

Best Contextual Advertising Platforms for CTV in 2026

Ethan Steininger — Tue, 10 Nov 2026 16:08:01 +0000

The best contextual advertising platform for CTV depends on where you sit in the buy. Anoki ContextIQ and Wurl match ads to the scene playing before the break. Peer39 and Gracenote supply program-level categories (genre, rating, mood, language) that buyers apply pre-bid in their DSP. IRIS.TV, owned by Viant, tags each video with an ID that travels in the bid stream. IAS Total TV reports the show, genre and rating an ad ran against. KERV adds object-level recognition inside the frame. If you are a publisher or CTV platform that wants to label its own video, a developer API such as Mixpeek fits.

Program level or scene level

CTV contextual signals come in two grains.

Program level describes the whole show or episode: genre, rating, network, language, mood. Most streaming publishers already have it, and it is enough for broad suitability and genre buys.

Scene level describes a moment inside the show. A film labeled "drama" can hold a dinner party, a car chase and a funeral, and each suits a different advertiser. Scene signals matter when the ad should match what the viewer has just watched.

Many buyers have neither. Peer39's May 2026 market digest cites its CTV Truths report: 60% of CTV bid requests still lack usable program-level signals. So the first question is often whether any content signal reaches the auction at all.

The shortlist

Platform	Grain	How it reaches the buy
Anoki ContextIQ	Scene	Index Exchange Marketplaces, through existing SSP and DSP workflows
Wurl	Scene	Content Intelligence Platform, being integrated with Yahoo DSP, StackAdapt and Viant
Peer39	Program	Pre-bid contextual and suitability categories in DSPs
Gracenote (Nielsen)	Program	Categories built on Gracenote metadata, offered through Peer39 partner DSPs; Magnite was the first SSP to support them
IRIS.TV (Viant)	Video	A content ID passed in the bid stream, with signals such as genre, sentiment and brand safety
IAS Total TV	Program	Measurement of show, genre, rating and language on Disney, NBCUniversal, Paramount and Prime Video
KERV	Object	Object-level recognition and ad-break targeting, part of Wurl's platform
Mixpeek	Scene	API that classifies your own video into IAB Content Taxonomy 3.1 for your stack to send

A few notes from the vendors' own announcements:

Index Exchange describes Anoki's data as scene-level understanding of "content tone, sentiment, and subject matter", activated with no added platform fees.
Wurl launched its Content Intelligence Platform on September 15, 2026, combining its own scene-level targeting with KERV, Peer39 and Viant's IRIS.TV.
Gracenote's categories cover genres, ratings, content types and advisories, and buyers can target or exclude metadata such as mood, theme, subject and location. Buyers do not get show or episode titles.
IAS lists pre-bid optimization for CTV as a roadmap item for Total TV.

How to choose

You buy CTV and want the ad to match the moment: Anoki or Wurl. Ask which SSPs and DSPs you can activate them in today.
You need genre, rating and suitability controls across many publishers: Peer39, with Gracenote metadata if you want the program descriptors.
You already buy through Viant: IRIS.TV video-level data is the shortest path.
You need proof of where the ad ran: IAS Total TV for post-bid reporting.
You sell the inventory and want to label it yourself: classify your own video and send the categories in the bid request (below).

Before you sign, ask what grain the product returns (program, fixed time window, or scene) and how the signal reaches the auction: a deal ID, a DSP segment, or fields in the bid request.

How do we target CTV contextually without viewer data?

Contextual targeting reads the content and ignores the person watching it. No device IDs, household graphs or cookies are involved. The signal comes from three places.

The bid request itself. OpenRTB 2.6 has a content object under app (and site) with fields built for this: genre, livestream (0 for on-demand, 1 for scheduled linear), network, channel, and cat with cattax. cat holds IAB Tech Lab category IDs, and cattax names the taxonomy they come from. In the AdCOM list of category taxonomies, 9 means Content Taxonomy 3.1. Watch the default: if cattax is missing, the spec says Content Category Taxonomy 1.0 is assumed, so 3.1 IDs sent without it get read against the wrong tree.

Program metadata. Vendors like Gracenote and Peer39 describe the show, and buyers apply those categories in the DSP before bidding.

The video. Scene-level systems classify frames, speech and on-screen text, store the result with timestamps, and look it up at the ad break. Classification happens when the content is ingested, so the auction reads stored IDs and never waits on a model.

A publisher controls this last option itself. The categories describe its own inventory and travel in standard OpenRTB fields.

Classifying your own CTV inventory with Mixpeek

Disclosure: I work on Mixpeek.

Mixpeek labels video the customer already owns. It buys no media and runs no exchange; your SSAI vendor or SSP carries the categories into the auction.

The pipeline has three steps.

1. Cut each episode into scenes. Point Mixpeek at the bucket where the video lives (S3, GCS or another object store). The multimodal extractor splits video with split_method: "scene" and a scene_detection_threshold, and each segment comes back as its own document with start_time, end_time, a transcript, OCR text and a description.

2. Classify each scene against IAB Content Taxonomy 3.1. The taxonomy is generated from IAB Tech Lab's published 3.1 file, and a unit test diffs every ID, name, parent and tier against that file, so a renamed category or moved parent fails the test. Taxonomies can be materialized at ingest, which stores the categories on each scene document. Each scene gets tier 1 to tier 4 category IDs, a confidence score per category, and its timestamps.

3. Send the categories at the break. When a cue marks an ad break, look up the scene that ended at the cue and put its IDs in the content object:

{
  "app": {
    "content": {
      "livestream": 0,
      "cattax": 9,
      "cat": ["210", "216"]
    }
  }
}

In the 3.1 file, 210 is Food & Drink and 216 is its child, Cooking. A cookware buyer can now bid on the kitchen scene inside a show whose genre is drama.

Scores move from category to category, so set a cutoff for each one from labeled examples before the IDs go into an auction.

To see what the classifier returns before writing code, paste a transcript or a short scene description into the free IAB contextual classifier. It ranks categories across all four tiers by score. The longer walkthrough is in how scene-level contextual targeting works for CTV, and why CTV bid requests lack content categories covers the supply side.

Sources

Tools That Analyze the Hooks in Your TikTok and Meta Video Ads

Ethan Steininger — Tue, 10 Nov 2026 16:07:25 +0000

The tools that analyze the hooks in your top TikTok and Meta video ads fall into three groups. Motion and Superads connect to your ad accounts and score each video's opening with a hook metric built from thumb-stop and early-view data. Segwise and Atria use AI to find and tag hooks in your own ads and tie them to results, with Segwise built for mobile apps and games. Crux tags creative elements across connected Meta, TikTok and Google accounts and adds competitor research. Foreplay surfaces top hooks in competitors' ads. If you want to break your own ad archive into scenes and query the first three seconds yourself, a developer API such as Mixpeek fits.

What "hook analysis" means in practice

The hook is the opening of a video ad, usually the first two or three seconds. Teams ask three different questions about it:

Is this hook holding attention? A metric question, answered from platform data like 3-second views over impressions.
What kind of hook is it? A tagging question: problem callout, product to camera, creator talking head, text-only open.
Which hook types win across hundreds of ads? A comparison question, answered by joining the tags to performance.

The first question needs a connection to the ad account. The second needs something that watches the video. The third needs both, plus a consistent tag set so two strategists label the same hook the same way.

The shortlist

Tool	Best for	What it does with hooks
Motion	DTC brands on Meta and TikTok	Hook score from thumb stop and first frame retention; AI tags that include hook and creative angle
Superads	Brands and agencies wanting a scored view	Hook Score for video ads; AI labels that include hook type
Segwise	Mobile apps and games	AI tags for hook headline, hook tactic and hook visual format, tied to ad network and MMP data
Crux	Performance teams that also want competitor research	AI tagging, creative deep-dives and custom breakdowns on connected ad accounts
Atria	DTC teams on Meta and TikTok	An AI analyst that finds the personas, hooks and messages that keep winning
Foreplay	Creative strategists doing research	Saved ads with transcription; a competitor tracker that identifies top hooks
Vidmob	Enterprise brands	Element-level creative analysis and creative scoring across major ad platforms

Which tools break an ad into hook, scenes and messaging?

Many creative analytics tools work at the level of the whole ad: they attach tags like "hook: problem callout" or "format: UGC" to an ad ID and report on those tags. That is the right shape for weekly reporting.

A per-scene breakdown is a different output. You get the ad cut at each shot change, with a start and end time on each piece, plus what was said, what text was on screen and what the shot shows. That lets you look at the hook as its own object, and also see what happens in the scenes after it: where the product first appears, when the offer lands, how long the creator stays on screen.

Ask any vendor you evaluate whether their tags are per ad or per time range, and whether you can export them with timestamps.

How creative strategists tag and compare hundreds of ads

The workflow that holds up at a few hundred ads looks like this:

Fix the tag set first. Write down your hook types with a one-line definition and one example ad each. A tag set that drifts between people makes the comparison meaningless.
Tag the hook separately from the body. An ad that opens on a creator and cuts to a product demo should carry both, at different times.
Join to performance by ad ID. Keep spend, hook rate and conversions in the same table as the tags.
Compare within a format. A UGC hook and a motion graphics hook rarely compete for the same placements.

If your ads live on Meta and TikTok and you want this done for you, Motion, Superads or Atria cover it. If you run an app, start with Segwise. If you want to save and study competitors' hooks, Foreplay or Crux.

Doing hook analysis on your own ad archive

Disclosure: I work on Mixpeek.

Mixpeek does not connect to your Meta or TikTok ad accounts and does not pull performance metrics. You bring the video files from your own object storage, and you join performance data yourself by ad ID. What it gives you is the per-scene breakdown described above, as an API you can query.

1. Cut every ad into scenes at ingest. The multimodal extractor splits on visual change with split_method: "scene". Scenes longer than max_segment_duration (30 seconds by default) are split further. Turn on transcription, OCR and descriptions so each scene carries what was said, the on-screen text and a description of the shot.

{
  "feature_extractor": {
    "feature_extractor_name": "multimodal_extractor",
    "version": "v1",
    "input_mappings": { "video": "video_url" },
    "field_passthrough": [{ "source_path": "metadata.ad_id" }],
    "parameters": {
      "split_method": "scene",
      "scene_detection_threshold": 0.5,
      "run_transcription": true,
      "run_ocr": true,
      "run_video_description": true
    }
  }
}

Each scene comes back as its own document with start_time, end_time, transcription, ocr_text, description and a thumbnail_url. If you would rather cut on a fixed clock, split_method: "time" with time_split_interval does that.

2. Pull just the hooks. In a retriever, an attribute filter on start_time keeps only the opening segments:

{
  "stage_name": "attribute_filter",
  "stage_type": "filter",
  "config": {
    "stage_id": "attribute_filter",
    "parameters": { "field": "start_time", "operator": "lt", "value": 3 }
  }
}

3. Ask questions a tag list cannot. An LLM filter judges each hook against a plain-language criterion. With include_media: true the segment's media goes to the model along with its fields, so the judgment is made on what the opening shows.

{
  "stage_name": "llm_filter",
  "stage_type": "filter",
  "config": {
    "stage_id": "llm_filter",
    "parameters": {
      "criteria": "Keep only hooks where a person holds the product up to the camera",
      "include_media": true,
      "include_reasoning": true
    }
  }
}

4. Make your hook types stick. A taxonomy matches each segment against a reference collection, such as one example clip per hook type, and attaches the label. With taxonomy_applications set to execution_mode: "materialize", every new ad gets labeled at ingest with the same definitions, so the tag set stops drifting between people.

The creative DNA template sets most of this up in one step: scene-level ad documents with brand and ad ID, a separate searchable collection for ad copy, and clusters that group scenes into recurring visual patterns.

On cost, the public rate for video search (scenes, speech transcript and descriptions) was 0.05 USD per minute of video when I checked on 10 November 2026, with on-screen text as a 0.10 USD per minute add-on (pricing). A library of 1,000 thirty-second ads is 500 minutes.

From there, export the labeled hooks with their ad_id, join them to the spend and hook-rate numbers from your ad platform, and compare hook types in whatever reporting tool you already use.

How to fine-tune an embedding model with LoRA adapters

Ethan Steininger — Tue, 03 Nov 2026 16:05:42 +0000

To fine-tune an embedding model with LoRA, freeze the base encoder, attach a small LoRA adapter to its linear layers, and train only the adapter with a contrastive loss on (query, relevant passage) pairs from your own domain. With Sentence Transformers this is a few lines: build a LoraConfig with task_type=FEATURE_EXTRACTION, call model.add_adapter(), and train with MultipleNegativesRankingLoss. A few hundred to a few thousand clean pairs is usually enough. The adapter comes out at a few megabytes. Afterwards you must re-embed your whole corpus, because the fine-tuned model's vectors are not comparable with the old ones.

Why LoRA fits embedding models

Full fine-tuning updates every weight and leaves you with a second full copy of the model. LoRA freezes the weight matrix W and learns a low-rank correction B·A on top of it, scaled by alpha / r. Only A and B train.

For an encoder that matters in three ways:

Small files. The Sentence Transformers docs show a LoRA adapter for bert-base-uncased at 9.44 MB, 2.14% of the base model's weights.
Less forgetting. The base weights never change, so the model keeps most of what it knew before.
Many domains, one base. You can keep one encoder loaded and switch adapters per tenant, language or domain.

What your training data looks like

An embedding model learns from pairs, not from next-token prediction. Each row is an anchor (usually a query) and a positive (the passage that should come back for it). A hard negative, something that looks relevant and is not, is optional and often helps.

anchor	positive	negative (optional)
torque spec for M8 flange bolt	M8 flange bolts on the intake manifold are tightened to 25 Nm...	M8 hex bolts on the exhaust bracket use 30 Nm...
refund window for annual plans	Annual plans can be refunded in full within 30 days...	Monthly plans renew automatically on...

Good sources of pairs: search logs with clicks, support tickets matched to the doc that resolved them, and headings matched to their sections. Clean pairs matter more than volume.

The code

This uses Sentence Transformers 3 or later with peft installed (pip install sentence-transformers peft datasets).

from datasets import Dataset
from peft import LoraConfig, TaskType
from sentence_transformers import (
    SentenceTransformer,
    SentenceTransformerTrainer,
    SentenceTransformerTrainingArguments,
)
from sentence_transformers.losses import MultipleNegativesRankingLoss

# Load the base encoder in fp32 for training
model = SentenceTransformer(
    "BAAI/bge-base-en-v1.5",
    model_kwargs={"torch_dtype": "float32"},
)

# Attach a LoRA adapter; only these weights train
peft_config = LoraConfig(
    task_type=TaskType.FEATURE_EXTRACTION,
    inference_mode=False,
    r=16,
    lora_alpha=32,
    lora_dropout=0.1,
)
model.add_adapter(peft_config)

# Your (anchor, positive) pairs; add a "negative" column if you have hard negatives
train = Dataset.from_dict({
    "anchor": ["torque spec for M8 flange bolt", "refund window for annual plans"],
    "positive": [
        "M8 flange bolts on the intake manifold are tightened to 25 Nm.",
        "Annual plans can be refunded in full within 30 days of purchase.",
    ],
})

args = SentenceTransformerTrainingArguments(
    output_dir="bge-base-lora",
    num_train_epochs=1,
    per_device_train_batch_size=32,
    learning_rate=2e-4,
    warmup_ratio=0.1,
)

trainer = SentenceTransformerTrainer(
    model=model,
    args=args,
    train_dataset=train,
    loss=MultipleNegativesRankingLoss(model),
)
trainer.train()

model.save_pretrained("bge-base-lora-adapter")

MultipleNegativesRankingLoss treats every other positive in the batch as a negative for each anchor, so larger batches give it more to learn from. LoRA trains comfortably at a higher learning rate than full fine-tuning; 2e-4 is a common starting point.

To use the result, load the adapter folder like any model: SentenceTransformer("bge-base-lora-adapter"). You can also load the base model and call model.load_adapter(...). The Sentence Transformers PEFT docs cover both.

Settings that matter

Rank and alpha. r=16 with lora_alpha at r or 2r is a sound default. Raise r only when an evaluation shows the adapter is underfitting.
Target modules. If you leave target_modules out, PEFT picks defaults for known architectures (for BERT, the attention query and value projections). Adding the other linear layers gives the adapter more capacity for a little more memory. The PEFT LoRA reference lists the options.
Evaluation before and after. Hold out a few hundred of your own queries with known answers and measure recall@10 or nDCG@10 on the base model first. Sentence Transformers' InformationRetrievalEvaluator does this. If the base model already scores well, a better base model, hybrid search or a reranker may help more than fine-tuning.
Forgetting. Check a general benchmark too. A large drop there means the learning rate was too high or you trained too long.

The step most tutorials skip: re-embedding

Fine-tuning changes the geometry of the vector space. Vectors from the base model and vectors from the fine-tuned model cannot be compared, so they cannot live in the same index. After training you re-embed every document with the new model, and every query has to use the same adapter.

On a large corpus, that re-embedding pass costs more than the training. Plan it like a migration: build the new index next to the old one, compare results on your evaluation set, then switch traffic.

Where Mixpeek fits

Disclosure: I work on Mixpeek.

Mixpeek stores and searches vectors you compute yourself, including ones from a fine-tuned encoder, next to the documents and metadata they came from. During a re-embed you can keep the old and new vectors in separate collections and compare them on the same queries before you switch. Two longer write-ups on our site go deeper: how LoRA fine-tuning works, including QLoRA and DoRA, and changing embedding models without breaking your index.

The best creative intelligence platforms for video ads in 2026

Ethan Steininger — Tue, 03 Nov 2026 16:03:33 +0000

The best creative intelligence platform for video ads depends on who you are. Motion is the usual pick for DTC brands that want creative reporting across Meta, TikTok, YouTube and LinkedIn. Vidmob and CreativeX fit enterprise brands that score creative against platform and brand guidelines. Segwise and AppsFlyer Creative Optimization fit mobile app and gaming teams that tie creative elements to installs. Atria, Foreplay and Crux add competitor ad research. If you want to search your own ad archive by what happens on screen, or build creative analysis into your own tools, a developer API such as Mixpeek fits.

What "creative intelligence" covers

The term gets used for four different jobs:

Reporting. Which ads, hooks and formats drove spend and results, pulled from the ad platforms.
Tagging. Breaking each video into elements (hook, scenes, people, product shots, on-screen text, voiceover) so results can be compared by element.
Scoring. Checking creative against platform best practices or brand guidelines, before or after launch.
Research. Browsing and saving competitors' ads from public ad libraries.

Most tools do one or two of these well. Decide which job you have first.

The shortlist

Platform	Best for	Main job
Motion	DTC and consumer brands	Visual creative reporting across Meta, TikTok, YouTube and LinkedIn
Vidmob	Enterprise brands and agencies	Creative scoring and measurement across many platforms
CreativeX	Global brands with many markets	Creative quality and brand guideline compliance
Segwise	Mobile apps and games	Element tagging tied to ad network and MMP data
AppsFlyer Creative Optimization	Apps already on AppsFlyer	Creative breakdowns tied to installs and downstream events
Atria	DTC teams	Competitor ad research plus analytics
Foreplay	Creative strategists	Saving and organizing ads from public libraries
Crux	Larger performance teams	Creative analysis with competitor intelligence
Pencil	Teams producing many variants	Generating ads and predicting which will perform

How to choose

Your ads run mostly on Meta and TikTok, and you need weekly answers on what is working: start with Motion, or Atria if you also want competitor research in the same place.
You run a mobile app or game: Segwise, or AppsFlyer's module if you already use AppsFlyer. Element tags tied to installs matter more there than reach.
You are a large brand with guidelines across many markets: Vidmob or CreativeX, which score creative before it ships.
You want ideas from what competitors run: Foreplay, Atria or Crux.

Before you sign, check three things: which ad platforms it connects to, whether it analyzes the video itself or only the platform metrics, and whether you can export the tags it produces.

When an off-the-shelf platform is not enough

Disclosure: I work on Mixpeek.

The platforms above work on the accounts you connect and the tags they define. Some teams need something else: search across years of ads by what is on screen ("the hook where someone holds the product to camera"), their own tag set, or creative analysis inside their own dashboards.

That is what Mixpeek's creative DNA template does. It cuts every ad into scenes at ingest, makes the ad copy searchable beside them, and groups scenes into recurring visual themes per brand. A query returns the scene with its ad, brand and start and end time. Our measured run covered 271 ads, which came out at 2,306 scenes with a median length of 2.5 seconds. You query it through an API, so the results can feed whatever reporting tool you already use.

For the contextual targeting and brand suitability side of ad tech, our ad tech platform list compares DoubleVerify, IAS, Zefr, Peer39 and others.

Agentic search over a hierarchy of document clusters

Ethan Steininger — Sat, 24 Oct 2026 23:07:57 +0000

To run agentic search over a hierarchy of document clusters, first cluster the corpus: embed every document, then split the embeddings recursively into a tree, and give each cluster a label and a short summary. At query time an agent navigates the tree top-down. It reads the summaries at one level, chooses which clusters to open, descends into them, and runs vector or keyword search only inside the chosen leaf clusters. It stops when the evidence it has gathered answers the question. The agent never sees the whole corpus, only the summaries on its path and the chunks from a few leaves. The rest of this post covers why that works, how to build the tree, what the loop looks like in code, and where it fails.

Why search a tree instead of the whole index

Flat vector search ranks every chunk against the query. On a large, varied corpus the top results often include chunks that share vocabulary with the query and come from the wrong topic. An agent that retrieves those chunks has to spend context reading them.

A cluster tree changes three things:

Bounded context. A summary of a cluster is short. An agent can read the summaries of ten sibling clusters in a few hundred tokens and decide where to look, so the amount of text in its prompt grows with the depth of the tree. The size of the corpus barely moves it.
Fewer irrelevant chunks. Once the agent has picked a branch, the final search runs against that branch only. A query about "mountain" never competes with chunks from a cooking archive.
An explainable path. The route from root to leaf (for example Sports > Skateboarding) is a record of why a document was returned. You can log it, show it to a user, and debug it when the answer is wrong.

Building the tree

The tree has three ingredients: embeddings, a clustering algorithm applied recursively, and a label plus summary for every node.

Embed. Use one embedding model for the whole corpus so distances mean the same thing at every level.

Cluster recursively. Run a clustering algorithm on the whole set to get top-level groups, then run it again inside each group that is big enough to split, and keep going until groups are small or you reach a depth limit. K-means works when you know roughly how many groups you want at each level. HDBSCAN works when you do not, and it marks outliers as noise instead of forcing them into a group. In both cases, reducing dimensionality first (UMAP is common) tends to make the splits cleaner.

Label and summarize. For each cluster, sample member documents and ask an LLM for a short label and a one or two sentence summary. These two fields are what the agent reads while navigating, so their quality sets the ceiling on the whole system. A label such as "Species" on a parent that holds both animals and landforms will send queries about mountains down the wrong branch.

The best-known paper on this family of ideas is RAPTOR: Recursive Abstractive Processing for Tree-Organized Retrieval (Sarthi, Abdullah, Tuli, Khanna, Goldie and Manning, January 2024). Its abstract describes recursively embedding, clustering and summarizing chunks of text to build a tree with different levels of summarization, and reports that pairing RAPTOR retrieval with GPT-4 improved the best prior result on the QuALITY benchmark by 20 percentage points of absolute accuracy. RAPTOR retrieves from the tree. The loop below adds an agent that decides which branches to open.

The agent loop

Give the agent three tools:

list_children(cluster_id) returns the child clusters with their labels and summaries. With no argument it returns the top level.
read_summary(cluster_id) returns the full summary of one cluster.
search_within(cluster_id, query) runs vector or keyword search over documents in that cluster and its descendants.

A sketch in Python, with llm_choose and enough_evidence standing in for whatever model calls you use to pick clusters and judge sufficiency:

def agentic_search(query, tree, llm_choose, beam=3, max_depth=4, max_hits=20):
    frontier = [tree.root]            # clusters we are about to open
    leaves = []

    for _ in range(max_depth):
        candidates = []
        for node in frontier:
            kids = tree.list_children(node)
            if not kids:
                leaves.append(node)   # nothing below: search here
                continue
            candidates += kids

        if not candidates:
            break

        # The model sees label + summary for each candidate and
        # returns the `beam` most promising ones.
        frontier = llm_choose(query, candidates, k=beam)

    leaves += frontier
    hits = []
    for leaf in leaves:
        hits += tree.search_within(leaf, query)

    # Stop when the evidence suffices, otherwise widen the beam and retry.
    if enough_evidence(query, hits):
        return hits[:max_hits]
    if beam >= 9:
        return hits[:max_hits]
    return agentic_search(query, tree, llm_choose, beam=beam + 2)

Three details matter in practice.

First, ask the model to score every child, not to name one. Scores let you keep the top beam paths and rank finished paths against each other. Averaging scores with a geometric mean keeps a deep leaf from being penalized for having more decisions behind it.

Second, show a parent cluster to the model as the leaves reachable below it. A parent label is a compromise, and the leaf names tell the model what is actually inside.

Third, give the agent an explicit stop rule. Without one it keeps descending or searching after the answer is already in context.

Costs and failure modes

A wrong branch early. The biggest risk is the first decision. If the agent opens the wrong top-level cluster, everything below it is searching the wrong region, and the final answer can be confidently wrong. Two mitigations help. Keep a beam of k branches at each level, so a near-miss on the first choice is still alive at the second. And let the agent backtrack: if search_within returns weak hits, return to the last level where a sibling scored close and try that one.

Model calls per level. Every level costs a model call. A tree of depth three with a beam of three costs a handful of calls before any retrieval happens. Batch the candidates for all paths at one level into one request, and use a small, fast model for navigation decisions since each one is a short classification.

Stale clusters. Clusters describe the corpus as it was when you ran the clustering. New documents either land in the nearest existing cluster or sit outside the tree, and labels drift out of date as content shifts. Re-cluster on a trigger: a schedule, a document count threshold, or a quality signal such as falling cohesion or a rising share of outliers.

Summary quality. A vague summary hides a cluster from the agent. Spot-check labels and summaries when you build the tree, and keep a set of queries with known answers to run after every rebuild.

What Mixpeek documents

Mixpeek's Agent Search retriever stage has a cluster_navigation strategy. Per the docs, a cluster run writes one centroid document per cluster with its label, summary and parent_cluster_id. The stage starts at the top-level clusters, asks a decision model which child cluster most likely holds documents that answer the query, and repeats until it reaches leaf clusters. It then returns the member documents of the best leaves. The walk is a beam search: beam_width defaults to 3, and max_leaf_clusters sets how many leaves return members. Each returned document carries cluster_path and cluster_path_score, and the stage metadata includes a navigation_trace with the candidates and probabilities at every level. The stage returns the members of the chosen clusters. It does not run a separate vector search inside them, though you can chain a search stage after it. The docs do not describe backtracking.

On the build side, the Clusters docs describe vector clustering with eight algorithms including HDBSCAN and K-Means, optional UMAP preprocessing, and hierarchical sub-clustering through hierarchical: true and max_hierarchy_depth. LLM labeling is configurable per cluster. Each execution reports quality metrics, including a should_recluster recommendation, and clusters can be re-run automatically with cron, interval or event-based triggers. The hierarchical search tutorial walks through the whole sequence from clustering to a retriever that navigates the tree.

Disclosure: I work on Mixpeek. Mixpeek builds clusters over collections, including hierarchical vector clusters with LLM-written labels (Clusters docs), and its Agent Search stage can navigate those clusters top-down with the cluster_navigation strategy (Agent Search docs). The tutorial linked above shows the end-to-end setup.

Is There a Reverse Video Search? How It Works, How to Build One

Ethan Steininger — Sat, 24 Oct 2026 23:07:57 +0000

Yes. Reverse video search exists, but the big search engines do not offer it as a single upload box. The usual workflow is to pull keyframes out of the video and run each one through a reverse image search. Under the hood, a dedicated system does the same thing at scale: it samples frames or detects shot boundaries, turns each frame into a perceptual hash or an embedding, stores them in an index, and matches the frames of your query clip against that index. The best-matching frames also carry timestamps, so the answer comes back as "this file, at 01:42". Consumer tools search the public web's image index. If you want to search a video library you own, you build or buy the index yourself.

Consumer options

Google Lens. Google's help page says you can search with an image by uploading a file, dragging it in, or pasting an image URL. Take a frame from the video, save it as an image, and upload it. The page does not mention video input, so the frame step is yours.

Bing Visual Search. Microsoft's support page describes searching the web with an image from the camera icon on Bing Images. It accepts uploads, pasted images and URLs. Same workflow: export a frame, upload it.

TinEye. TinEye fingerprints the image you submit and compares it with its index, which it builds by crawling the web. Its help center says it finds exact and altered copies, including cropped, color adjusted, resized, heavily edited or slightly rotated ones, and that it does not commonly return similar images of the same subject. Its help pages describe image search only.

InVID-WeVerify. This browser plugin was built for journalists and fact-checkers. Its keyframe tab takes a video URL or an uploaded file, segments it into keyframes, and lets you right-click a keyframe to search it on Google, Yandex, TinEye and Baidu. It automates the manual workflow above, so it is the quickest way to try it.

YouTube Content ID. Content ID does match video, but only for rights holders. Google's help page says owners must hold exclusive rights to a substantial body of original material that is frequently uploaded to YouTube. They supply reference files, and every new upload is scanned against that library. A regular user cannot submit a clip and ask where it appears.

What these tools miss

All four web options search an index of images. None of them has your video in it. That has practical consequences:

A clip that circulated only as video, never as a thumbnail, screenshot or article image, may have no still in the index to match.
You choose which frames to search. A frame from a title card or a black transition returns nothing useful, and a single frame says nothing about when in the clip it occurs.
Copies that were cropped, mirrored, letterboxed, overlaid with captions or re-encoded at low quality produce frames that differ from the originals. TinEye's documentation covers crops and edits, but horizontal flips and heavy overlays are where fingerprint matching usually gives out, so test your own samples.
Your private footage is not on the web, so no public tool can find it. Searching a library you own requires indexing it.

Build one over your own library

The pipeline has four steps.

1. Sample frames. The simplest approach is a fixed rate such as one frame per second. A more economical one is shot-based: ffmpeg's select filter exposes a scene score between 0 and 1, and the documentation says a threshold between 0.3 and 0.5 is generally a sane choice. Extract one representative frame per shot and store its timestamp.

2. Choose a fingerprint. Perceptual hashes (average, perceptual, difference, wavelet) from the imagehash library produce a short code, and the distance between two codes is a Hamming distance. They are cheap and handle re-encoding, resizing and mild color shifts. They are weak against heavy crops and flips. Embeddings from a vision model such as CLIP are larger and need a vector index, but they tolerate more edits and also support searching by meaning. Many systems run a hash for near-exact copies and embeddings for everything else.

3. Index. Store one row per sampled frame: video ID, timestamp, hash or vector. For hashes, a linear scan over a few million rows is fine. Past that, use a vector database or a BK-tree.

4. Align in time. Matching single frames gives noisy results, because unrelated frames sometimes collide. Real matches agree on an offset. If query frame at 3 s matches library frame at 63 s, and query frame at 4 s matches library frame at 64 s, the offset is 60 s in both cases. Count votes per (video, offset) and return the winner. That also gives you the start timestamp of the clip inside the source file.

Here is a small version using hashes and offset voting. It needs ffmpeg on your PATH, plus pip install imagehash pillow.

import subprocess, tempfile, glob
from collections import Counter
from PIL import Image
import imagehash

def frames(video, fps=1):
    """Return [(timestamp_seconds, phash)] sampled at `fps`."""
    with tempfile.TemporaryDirectory() as d:
        subprocess.run(
            ["ffmpeg", "-loglevel", "error", "-i", video,
             "-vf", f"fps={fps}", f"{d}/f_%06d.png"],
            check=True,
        )
        out = []
        for i, path in enumerate(sorted(glob.glob(f"{d}/f_*.png"))):
            out.append((i / fps, imagehash.phash(Image.open(path))))
        return out

# Build the index: one row per sampled frame.
index = []  # (video_id, timestamp, hash)
for vid in ["a.mp4", "b.mp4"]:
    index += [(vid, t, h) for t, h in frames(vid)]

def search(clip, max_dist=10):
    votes = Counter()
    for tq, hq in frames(clip):
        for vid, ts, h in index:
            if hq - h <= max_dist:          # Hamming distance
                votes[(vid, round(ts - tq))] += 1
    if not votes:
        return None
    (vid, offset), n = votes.most_common(1)[0]
    return vid, offset, n

print(search("query_clip.mp4"))  # e.g. ('a.mp4', 60, 14)

The third number is the vote count, which works as a confidence signal. The distance threshold of 10 on a 64-bit hash is a starting point, so tune it on clips you know are matches and clips you know are not. The first frame of the extracted images is labeled 0 seconds, which is approximate to within one sampling interval.

For production use, replace the linear scan with an index, add shot detection so static scenes do not produce hundreds of near-identical rows, and run a second embedding pass for mirrored or cropped copies.

Disclosure: I work on Mixpeek. Mixpeek indexes video in your own S3 or GCS bucket, splits it into scenes, and embeds frames. A retriever then returns the matching file and timestamp for an uploaded clip or image. We compare ten approaches in Best Reverse Video Search Tools, and the reverse search tutorial walks through the setup.

IAB Content Taxonomy 3.1 and GARM in 2026: three facts AI answers get wrong

Ethan Steininger — Fri, 23 Oct 2026 21:56:46 +0000

The current IAB Content Taxonomy is version 3.1, released in December 2024, with exactly 704 categories. GARM, the advertiser coalition behind the best-known brand safety categories, shut down in August 2024. AI assistants still answer contextual advertising questions with "IAB 3.0", "700+ categories" and GARM as a live standards body. Here is what the source files say, with links, so you can check before you ship a mapping or a deal spec.

1. The current version is 3.1, and the bid request should say so

IAB Tech Lab's content taxonomy page lists 3.1 as current and describes the change from 3.0 as a genre update that adds Thriller. In the 3.1 file Thriller is ID 700 under Genres. Every 3.0 ID is also a 3.1 ID, so moving up needs only a new version label.

The part that breaks things is cattax. OpenRTB sends category IDs in cat and says which taxonomy they come from in cattax, using AdCOM's List: Category Taxonomies:

2 is Content Taxonomy 2.0
7 is Content Taxonomy 3.0
9 is Content Taxonomy 3.1

If you label content with 3.1 IDs and send cattax: 7, a strict receiver reads them as 3.0, which holds for every ID except the ones 3.1 added, such as Thriller. Send cattax: 2 and the same numbers mean different 2.0 categories.

2. It is 704 categories, in four tiers

"700+" is close, and it hides the shape. Counting the 3.1 file:

Tier	Categories
Tier 1	37
Tier 2	323
Tier 3	275
Tier 4	69
Total	704

The tier matters more than the total. Some classification services return only the top two tiers: the IAB list in Amazon Bedrock Data Automation's video output docs has 24 tier 1 and 85 tier 2 categories. If a buyer, an SSP or a curated deal asks for tier 3 codes, check the depth your classifier actually returns before you promise it.

3. GARM shut down in 2024, and its categories live on in vendor products

The World Federation of Advertisers discontinued GARM on 9 August 2024, days after X filed an antitrust suit against the WFA, GARM and its members. The WFA named no successor.

What survived is the Brand Safety Floor and Suitability Framework: eleven content categories, such as arms and ammunition, hate speech and terrorism, each graded by risk from floor to low. Platforms and verification vendors still use that vocabulary in their own products, and each now maintains its own version. IAB Tech Lab's human-labeled GARM benchmark was last updated in 2022, before the shutdown.

So "GARM-aligned" today means "uses categories that GARM defined". Nobody certifies it. Ask a vendor which version of the categories its labels follow and when it last changed them.

Quick checks before you ship

Your labels and your cattax value name the same version.
You know which tiers your classifier returns, and they match what your partners ask for.
Brand suitability tiers are written down as your own policy, with the vendor's category definitions attached.

Disclosure: I work on Mixpeek. We classify video, images, audio and pages into all 704 Content Taxonomy 3.1 categories, scene by scene for long video, and return IDs ready for cat with cattax: 9 (how it works). Our GARM explainer has the longer history, and the open-source IAB mapper converts 2.x labels to 3.1 IDs.

The best MCP servers for advertising agents in 2026

Ethan Steininger — Tue, 20 Oct 2026 15:21:27 +0000

The MCP servers an advertising agent needs fall into four groups. The ad platforms run their own servers for buying and reporting: Meta's Ads MCP at mcp.facebook.com/ads, Amazon Ads' MCP server (open beta, for partners with API access) and Google's open-source Google Ads MCP, which is read-only. Cross-channel data servers such as Improvado's put metrics from many platforms behind one interface. AdCP, the Ad Context Protocol, is the open standard for agents that buy media, activate signals and traffic creative between companies. Content-understanding servers tell an agent what is inside a video or page before it bids.

1. The platforms' own servers

Meta Ads MCP. A remote server hosted by Meta, documented under Ads AI Connectors. Its tools cover reporting, campaign and ad creation and editing, catalogs, datasets, A/B tests and lift studies. Apps need the ads_mcp_management permission.
Amazon Ads MCP server. Open beta for Amazon Ads partners with active API credentials. Its prebuilt tools run multi-step jobs such as creating a campaign with its ad groups and ads from one prompt.
Google Ads MCP. An open-source server from the Google Ads API team, googleads/google-ads-mcp. Its tools search the account, describe API resources and list accessible customers. It reads data and changes nothing.

Use these when the agent acts inside one platform. Each needs that platform's credentials, and each returns that platform's field names.

2. Cross-channel marketing data

Improvado's MCP server is a good example. It sits on Improvado's connectors and maps fields such as Google's cost and Meta's spend to one metric, so an agent can compare channels in a single query. Servers like this fit reporting and budget questions that span platforms. They need the vendor's platform underneath.

3. Agent-to-agent buying: AdCP

AdCP defines tasks that buyer and seller agents call over MCP or A2A. Examples are get_products and create_media_buy for media, get_signals and activate_signal for audience data, and build_creative and sync_creatives for creative. AgenticAdvertising.org stewards it, and the current release is 3.2.1. If your agent buys from publishers or sells inventory to other agents, implement AdCP so you do not build a custom integration for each counterparty. Some IAB Tech Lab work in this area overlaps; this comparison of AdCP and AAMP covers how they differ.

4. Content understanding

The servers above say what an ad account holds and what inventory costs. None of them says what is inside a piece of video, so they cannot answer whether a CTV episode is safe for a brand or which IAB category a scene belongs to. For that the agent needs a server that has indexed the media.

Disclosure: I work on Mixpeek. Mixpeek's MCP server (https://mcp.mixpeek.com/app/mcp, OAuth, read-only) lets an agent search video, images, audio and documents you have indexed from your own bucket, and run retrievers you define, for example one that classifies each scene into IAB Content Taxonomy 3.1. Setup docs.

A reasonable starting stack

One platform server for each platform where you buy.
A cross-channel data server if your reporting spans platforms.
AdCP if you buy from, or sell to, other agents.
A content server if any decision depends on what the creative or the inventory shows.

Give the agent read-only tools first, and add write access once its reads have proven correct.

Twelve Labs vs AWS for contextual advertising

Ethan Steininger — Tue, 20 Oct 2026 15:15:42 +0000

For contextual advertising, AWS gives you finished labels and Twelve Labs gives you stronger video models to build on. Amazon Bedrock Data Automation (BDA) splits a video into chapters and tags each one with IAB categories, along with on-screen text, logos and seven moderation classes, so you get targeting labels with no model work. Twelve Labs sells two models: Marengo, which turns video into embeddings, and Pegasus, which turns video into text. Turning their output into IAB codes, brand-safety flags or ad breaks is a pipeline you write and run. Both Twelve Labs models are also sold inside Bedrock, so one AWS account can use both.

What AWS gives you

BDA's standard video output has:

shots and chapters, with timestamps and a summary for each chapter
IAB categories per chapter
a full transcript with speaker labels
text that appears on screen, with bounding boxes
logo detection (off by default)
seven moderation categories, such as violence, alcohol and hate symbols

The IAB list in the BDA docs has 24 tier 1 and 85 tier 2 categories. IAB Content Taxonomy 3.1, the current version, has 704 categories across four tiers, 37 of them at tier 1. If a buyer, SSP or curation deal asks for tier 3 codes or a specific taxonomy version, plan for a mapping step.

AWS also publishes guidance for contextual advertising with generative AI, which builds the same kind of labels from multimodal models you choose.

What Twelve Labs gives you

Marengo turns video into embeddings, used for search and classification.
Pegasus turns video into text, for summaries and structured descriptions.

Marengo 2.7 and Pegasus 1.2 became fully managed models in Bedrock in July 2025. Twelve Labs' own API carries newer versions.

Their contextual ad engine tutorial shows what building on these models looks like. Pegasus 1.5 writes structured metadata for each scene. Marengo 3.0 embeddings feed search. The candidate labels are matched against IAB 3.1 rows, and the pipeline picks ad breaks and writes FreeWheel-style key-values. It ships as a reference build with a repo, so the pipeline is yours to run.

How to choose

You are on AWS and want labels this quarter: start with BDA. Check its category depth against what your partners expect.
You need to search an archive by what happens on screen, such as every scene at a beach at sunset, or define your own segments: embeddings fit better. That means Marengo, or any multimodal embedding you can run.
You need audited IAB 3.1 codes at full depth: either route needs a classification step you can measure. Label a few hundred of your own scenes by hand and compare top-1 accuracy before you commit.

A third option

Disclosure: I work on Mixpeek.

Mixpeek indexes video from your own S3 or GCS bucket, scene by scene. It classifies each scene into all 704 IAB Content Taxonomy 3.1 categories through a retriever you can inspect and change. On IAB Tech Lab's open 704-page benchmark, our 3.1 classifier scored 72.7% top-1 and 93.8% top-5. That benchmark is text only, and the write-up includes where it lost. A side-by-side with Twelve Labs is at mixpeek.com/comparisons/mixpeek-vs-twelvelabs.

Why your video search keeps returning the wrong scene

Ethan Steininger — Thu, 15 Oct 2026 19:35:02 +0000

Your search usually returns the wrong scene because of how the video was cut up before it was indexed. If you embed fixed time windows or every Nth frame, one vector can straddle two scenes, and the match lands on the neighbour. If you embed one vector per whole video, every query returns the same file. The fix is to segment first: detect shot boundaries, group shots into scenes, then embed each scene and store its start and end timestamps. A query then matches a coherent unit and returns the moment itself.

Where the wrong scene comes from

Fixed windows. Splitting every 10 seconds ignores where the cuts are. A window that holds the last three seconds of a kitchen scene and the first seven of a street scene produces an embedding that is half of each. Ask for "street at night" and you may get the kitchen timestamp.

Frame sampling without boundaries. Sampling one frame a second gives you lots of vectors, many nearly identical. The nearest neighbour is often a frame from a similar-looking shot elsewhere in the video.

One vector per video. Averaging a whole video into one embedding throws away where anything happens. Search can find the right file and still cannot tell you where in it.

How segmentation fixes it

Shot boundary detection. Compare consecutive frames. A hard cut spikes a histogram difference. Dissolves and fades spread the change over many frames, so an adaptive detector flags a boundary when the score beats a rolling local mean by two to three standard deviations.
Group shots into scenes. A shot is one camera take. A scene can span many shots, like a conversation cutting between two angles.
Clean up. Merge segments under about two seconds into a neighbour, and split long ones at audio silence.
Embed per scene, keep timestamps. One embedding per scene, stored with its start and end time. Results come back as moments.

This also cuts index size by 10 to 100 times, because you store one vector per scene.

Quick checks on your own pipeline

Print the boundaries of the scene your query wrongly returned. If a cut falls inside it, segmentation is the problem.
Check whether dissolves are being missed. A fixed threshold catches hard cuts and misses gradual transitions.
Check whether on-screen text or speech carries the meaning. If so, a visual embedding alone will keep missing, and you need OCR or transcript features on the same scene.

The full walkthrough, with the algorithms and thresholds: https://mixpeek.com/guides/video-scene-segmentation

Disclosure: I work on Mixpeek.

Vector search on S3, without a hosted vector database

Ethan Steininger — Thu, 15 Oct 2026 19:35:01 +0000

You can keep your vectors in S3 and search them there. Three ways work today. AWS S3 Vectors stores embeddings in a special bucket type and answers similarity queries through an API. LanceDB writes a columnar vector format to any S3 path and queries it from your process. A vector store built on object storage, such as Mixpeek's MVS, keeps the index and payloads in your bucket and runs dense, sparse and BM25 search over them. Pick by what you need beyond nearest neighbor: filters, hybrid keyword search, and how fast a cold query has to come back.

Why people move vectors to object storage

A hosted vector database keeps your whole index in memory on machines you rent all month. That is fine at a few million vectors. It gets expensive when most of your namespaces sit idle, which is the normal shape for multi-tenant apps and media archives.

Object storage flips the cost model. The data sits at storage prices, around $0.023 per GB-month on S3 Standard, and compute only runs when a query arrives.

The three options

S3 Vectors. Native to AWS. You create a vector bucket and an index, put vectors with metadata, and query by similarity. Good when you are all-in on AWS and need plain nearest-neighbor search with metadata filters.

LanceDB. An embedded library over the Lance file format. Point it at s3://bucket/path and query from your own code. Good when you want no server at all and your queries run inside one application.

A vector store on object storage. The index lives in your bucket, and a query layer loads what it needs, caches the hot parts, and scales idle namespaces to zero. MVS works this way: you bring your own vectors, run dense, sparse and BM25 hybrid search, and the vectors persist on your own S3-compatible storage. It also imports from Pinecone, Qdrant or Weaviate without re-embedding.

What to check before you switch

Cold latency. The first query against an idle namespace has to fetch from storage. Measure it on your own data size.
Hybrid search. If your users type exact product codes or names, pure vector search misses them. You want BM25 alongside dense vectors.
Filters at query time. Metadata filters should apply inside the search. A store that filters the top results afterwards hands back fewer than you asked for.
Write path. Check how writes become durable and searchable, and how long that takes.

Full details on how MVS does this, with a cost estimator: https://mixpeek.com/mvs

Disclosure: I work on Mixpeek.

How to Add Adjacency-Aware Contextual Targeting to Prebid in 15 Minutes

Ethan Steininger — Mon, 12 Jan 2026 04:11:26 +0000

Replace cookie-based targeting with privacy-first contextual signals — without blocking your auctions.

The Problem

Cookie deprecation is here. Third-party targeting signals are disappearing, and publishers need alternatives that:

Don't rely on user identifiers
Don't add latency to header bidding
Work with existing SSP/DSP infrastructure

The Mixpeek RTD module solves this by enriching Prebid bid requests with contextual + adjacency signals via standard OpenRTB fields.

What You'll Get

After this 15-minute setup, your bid requests will include:

Signal Type	Data
Contextual	IAB v3.0 categories, keywords, sentiment, brand safety score
Adjacency	Previous creative ID, bidder, ad categories

SSPs and DSPs consume these via ortb2.site.content and ortb2Imp.ext.data — no custom integration required on their end.

Step 1: Install the Module

npm install @mixpeek/prebid

Or add via CDN:

<script src="https://unpkg.com/@mixpeek/prebid@latest/dist/mixpeek-rtd.min.js"></script>

Step 2: Get Your Credentials

Sign up at mixpeek.com
Generate an API key in your dashboard
Create a collection with feature extractors
Note your namespace ID (format: ns_xxxxx)

Step 3: Configure Prebid

Add the RTD provider to your Prebid config:

import '@mixpeek/prebid'pbjs.setConfig({  realTimeData: {
    auctionDelay: 250,  // Max wait time (ms)
    dataProviders: [{
      name: 'mixpeek',
      waitForIt: true,
      params: {
        apiKey: 'YOUR_API_KEY',
        collectionId: 'YOUR_COLLECTION_ID',
        namespace: 'YOUR_NAMESPACE'
      }
    }]
  }
})

That's it. Bid requests are now enriched automatically.

Step 4: Verify the Output

Check that contextual data is being injected:

pbjs.onEvent('mixpeekContextReady', function(context) {
  console.log('Category:', context.taxonomy?.label)
  console.log('Keywords:', context.keywords)
  console.log('Brand Safety:', context.brandSafety)
})

Your ortb2 object will now include:

{
  "site": {
    "content": {
      "cat": ["IAB19-11"],
      "cattax": 6,
      "genre": "Technology",
      "keywords": "ai,technology,ml",
      "ext": {
        "data": {
          "mixpeek": {
            "score": 0.94,
            "brandSafety": 0.98,
            "sentiment": "positive"
          }
        }
      }
    }
  }
}

How DSPs Consume the Signals

DSPs can use the enriched data for:

Contextual Targeting

// Target technology content
if (ortb2.site.content.cat.includes('IAB19-11')) {
  // Bid on tech inventory
}

Competitive Separation

// Avoid back-to-back competing ads
const prevCat = ortb2Imp.ext.data.hb_mixpeek_prev_cat
if (prevCat === 'IAB18-1' && currentAd.category === 'IAB18-1') {
  // Skip this impression
}

Brand Safety

// Only bid on safe inventory
if (ortb2.site.content.ext.data.mixpeek.brandSafety > 0.9) {
  // Safe to bid
}

Shadow Mode: Risk-Free Testing

Want to test without affecting live auctions? Use shadow mode:

pbjs.setConfig({
  realTimeData: {
    auctionDelay: 0,  // No delay
    dataProviders: [{
      name: 'mixpeek',
      waitForIt: false,  // Don't wait for response
      params: {
        apiKey: 'YOUR_API_KEY',
        collectionId: 'YOUR_COLLECTION_ID',
        namespace: 'YOUR_NAMESPACE'
      }
    }]
  }
})

This logs contextual data without blocking auctions. Perfect for validating the integration before going