IAB content classification: dedicated classifier or LLM prompt

A dedicated IAB classifier and an LLM prompt make the same thing, a code on a page. They get there by opposite means. The classifier answers from a closed label set, bills per page, and cannot invent a category. The LLM writes its answer, takes any instruction, and can label outside the taxonomy. That is flexibility and risk at once. The quality evidence runs both ways. Every number in this market sits on model judged labels. This page prints the two public head-to-heads with owners and dates. It prices both unit shapes. It ends with the decision table.

Every number below names its owner and its date. The taxonomy facts come from the IAB Tech Lab's taxonomy page and the official taxonomy files, counted from the files on 28 October 2026. The wire facts come from the OpenRTB 2.6 spec and Google's Authorized Buyers guide, read the same day. Each quality row names who ran it. The one vendor head-to-head set carries its two caveats in the text. This platform's own lanes, iab-2x and iab-3x, sit in the classification family with per page metering. The decision guidance stands alone and works with either engine.

Last verified: 2026-10-28

What the searcher is actually deciding

The query family is a buyer mid decision. Search completions for the head term expand into a version band, "iab taxonomy 3.1" and "iab content taxonomy 3.1". They expand into an engine band, "iab classifier" and "iab taxonomy classifier". They end in a migration tail, "iab taxonomy mapping". All captured 28 October 2026. Google attaches six questions to the family in its 26 October 2026 capture. One comes from a buyer holding old codes: are you looking to map 1.0 and 2.0 codes to version 3.1. The ranking pages answer none of the engine question. I read the top nine results live the same day. They are the taxonomy owner's reference pages, vendor category lists, and one bidder's support table. Not one of them compares a dedicated classifier against a prompted model.

So the real question is not what IAB content classification is. It is which engine should produce the labels. At what unit cost. With what failure modes. Into which taxonomy version. Those four sub questions decide each other, and the order matters. The version you must emit narrows the engines. That choice narrows the cost shape. And the failure mode decides what you must audit.

One boundary first, because two products share this query. A URL categorization service answers from a crawled domain database. Both engines on this page take text you submit: article bodies, page text from your own systems, transcripts. If you do not hold the text, this is the wrong page. A domain lookup service is the right tool.

Two machines, one label

A dedicated classifier is an encoder tuned for one job. Text goes in, and the model scores each candidate category. Its label set is closed by construction: the model can only answer from the taxonomy it was built on. What comes out is data, a code with a confidence score. Same input, same answer. An open fine tune on the ModernBERT encoder shows the shape. It is published under Apache 2.0. It has 149 million parameters and a native 8,192 token window. Its label set is fixed: 35 Tier 1 categories of taxonomy 3.1. From its own card, read 28 October 2026.

An LLM prompted to classify is a writing job. The taxonomy, the output rules, and the content all ride the prompt. The model writes its answer one token at a time. One production team described the shape in the official taxonomy repository's own issue tracker in July 2026. Their network presents the model with the entire category tree on every request. They asked the taxonomy owner for per category definitions, because names alone leave real ambiguity. Their examples are worth keeping. "Convertible" can mean a car body style or a bond. "Shooting" can mean a sport or a crime report. Different classifiers reach different conclusions on the same text, they wrote. The issue sat unanswered.

That issue is the honest portrait of the LLM path. It works. It is flexible. Its weak point is not intelligence but definition. The taxonomy files ship a numeric ID, a parent, a name, and tier positions. They ship no scope notes. Whatever engine you pick inherits that gap.

The only public head-to-heads, study by study

Two benchmark runs exist in public. Both come from one rival edge host that serves its own IAB classifiers. Both were read in full on 28 October 2026. They are the vendor measuring its own product against a small model from a large model vendor. So they carry two caveats that never leave the table. One, the host is a vendor measuring its own product. Two, a language model judged every quality label, not people.

Read the two accuracy rows together. They disagree in direction. Both are true. In the blind pairwise read, a stronger model chose which answer was better without knowing the source. The classifier won two of three pairs. Against gold labels on multilingual short text, the prompted model led top 1 by eleven points. Neither row crowns an engine. They bracket it. Quality is close enough that the deciding axes become cost, speed, and label validity.

The academic layer agrees with the bracket, and it is not a vendor. A 2025 survey covered 32 datasets in 8 languages. Zero shot LLMs did well on sentiment. They lost on most other tasks. An EMNLP 2025 findings paper put the split in one line. Encoder models excel at pattern driven tasks. LLMs dominate tasks needing deep semantics or world knowledge. Taxonomy labeling is mostly pattern work against a fixed set of names. That is the encoder's home ground.

Two cells of this market's table stay empty, and the emptiness is the finding. No third party head-to-head of a dedicated IAB classifier against a 2026 frontier class model exists. Searches for one on 28 October 2026 returned nothing. And this platform's own quality numbers for its lanes publish only with the row, from a named evaluation. That cell stays a dash here, by the platform's own rule.

The decision table

The hybrid row is real and common. Run the classifier over the corpus. Route everything under your confidence floor to a person, or to an LLM as the reviewer. Write the settled cases back as overrides. The open fine tune above was itself built this way. Its training labels came from a small language model, its card states, over a news corpus of about 106,000 articles before downsampling. The LLM is a fine labeling tool at build time, under review. It is a risky labeling engine at serving time, unsupervised.

The version question picks the engine first

The version your buyers read decides more than any benchmark row. The version field on the wire is cattax, an integer that defaults to 1 in the OpenRTB 2.6 spec. When the field is absent, taxonomy 1.0 is assumed. Version 1.0 is the deprecated line. The taxonomy owner says it should not be used without sensitive content flags. Google's Authorized Buyers guide states it uses Content Taxonomy 1.0 as the default for its accounts. The same guide warns that using it can increase bid filtering where categories have no equivalent. In other words, the default is the worst row of the table below.

The values come from the AdCOM list the spec points to, read 28 October 2026. Production drift is worse than the table suggests. One major bidder's public support table carries five code systems side by side. Version 1.0 strings, 2.x numerics, 3.x numerics, and two others. A vendor help list that ranks on this query still documents the 1.0 category set, IAB1 through IAB26, in 2026. Mixed systems are the norm. That is why the engine question and the version question must be answered together.

The engine effects are concrete. A classifier is built for a version. It returns that version's codes and only those. The version choice is fixed at selection. A version change means a new model or a mapping step. The taxonomy owner's free mapper converts 2.x codes to 3.0 equivalents and runs on your machine. It maps codes you already hold. It does not read text. An LLM prompt can be retargeted to a new version by editing the prompt. That is real flexibility. The same model will also label into a version it was never given. That is the same flexibility, pointed the other way. The 2.x to 3.1 move itself, what broke and where codes moved, is its own project. The migration guide on this site owns that walkthrough.

Counting note, because the market's numbers disagree. The official 2.2 file carries 1,196 rows across 37 top level groups. Six of those groups are descriptors, like language and geography, not topics. The 3.1 file carries 704 rows, with the descriptor groups gone and the top level rebuilt. The taxonomy owner's framing, roughly 400 categories growing past 1,500, is a rounding over the topic only view. One of the two benchmark pages above prints a 704 label count against the 2.2 name. That is the 3.1 file count on the wrong version. Count from the files. Every count on this page did.

What a label costs on each engine

Unit rules first, rates second. The two engines do not bill the same thing.

On the classifier side here, a page is up to 2,000 tokens of submitted text, rounded up. The wallet is checked before work starts. A request refused at the door bills nothing.

cost per 1,000 pages here  =  ( P / 1,000 ) x R

P:  pages labeled; one page = up to 2,000 tokens of submitted text, rounded up
R:  per-1k-page rate from the fenced rows above

On the LLM side, the unit is the token, in both directions. The taxonomy rides every call.

LLM cost per 1,000 pages  =  ( Tin / 1,000,000 ) x Rin  +  ( Tout / 1,000,000 ) x Rout

Tin:   input tokens per 1,000 calls: instructions + the category list + the text
Tout:  output tokens per 1,000 calls: the labels and any prose the model writes
Rin:   the model's per-million input token rate, from its own card
Rout:  the model's per-million output token rate, from its own card

The load bearing fact is Tin. In the benchmark host's production case study, its classifier path took about 400 input tokens per call. The prompted path took roughly 2,000 to 3,000. Its instruction block, category list, and content run about 18 kilobytes, resent and rebilled on every request. An agency write up from August 2024 built the same thing with a small model plus retrieval over the taxonomy. It logged about 17,000 tokens per article. At those shapes the two meters are not close, and the gap widens with corpus size.

Rates stay relations on this page, never figures. At the shapes above, the smallest published tier of a large model vendor prices below the fenced rate on short text. Rates read 28 October 2026. The upper tiers price far above it. The relation flips with your average text length. That is the sensitivity line, and there is only one. Know your tokens per page before trusting either side.

Self hosting is the third shape, and the open pack makes it real. The ModernBERT base encoder is Apache 2.0 with a native 8,192 token window, per its card. The 3.1 fine tune above runs on it. Your bill becomes hardware and time. Open choices are thin at the deep tiers. The strongest public fine tune covers 35 Tier 1 categories. A Mozilla classifier in the same space ships 21 labels from a 1.0-era vocabulary with no published metrics. Both read 28 October 2026.

Audit: the part a compliance reader sees

Ad tech labels get read by people whose job is to distrust them. The two engines fail differently under that reading.

A closed set classifier returns codes that either exist in the file or do not. Validation is a lookup. Same text in, same codes out, so a sample audit extends to the corpus. The failure mode is quiet: a wrong but valid code. A confidence floor and a review queue manage it. The benchmark host's constrained classifier emitted zero off taxonomy labels across its 10,000 row run. The prompted model in the same run invented labels on 1,796 rows. That is the compliance headline. An invented category is not a quality problem. It is a data integrity problem, and it is the LLM path's own published failure class.

The safety block makes the stakes concrete. Taxonomy 2.2 carries a Sensitive Topics group with exactly 11 categories. It carries a Brand Suitability and Risk group with exactly 4 levels. Both counted from the official file. The 3.1 file keeps the 11 sensitive topics. It drops the risk levels from the tiered file, where risk became a separate vector. The industry body that set the brand safety floor dissolved in August 2024. Its floor and risk tiers remain the working standard buyers screen against. Those labels are exactly what a buyer asks you to prove. A fixed label set with confidence scores is the easiest artifact to prove them from.

An LLM path can be made auditable. Constrain the output. Check every response against the file. Log prompts and model versions. Re run samples. Each step is real work that the classifier path gets by construction. Budget it, or the flexibility is borrowed against your audit.

Make the first call

The lanes ride one classification route: a JSON POST with a Bearer key. Sign up, create a key, fund the wallet, and send text. Text into 3.1 codes:

curl -X POST "https://api.ironstratum.com/v1/classification" \
  -H "Authorization: Bearer $KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "iab-3x",
    "input": "The harbor district renovation finished in March after two years of work, and the first new tenants open this weekend."
  }'

The answer carries 3.1 codes with labels and confidence. For stacks that still read 2.x, the same route with the 2.x lane's model id returns 2.2 codes. The migration guide covers the cross map between them. Metering is per page against a prepaid wallet, so a runaway backfill stops at the balance. That failure mode and its controls are covered in how to avoid API bill shock. Current rates for every lane sit on the pricing page. The OpenAI compatible API guide maps the wider request surface. The same decision shape for extraction, spans versus prompts, is worked in the GLiNER versus LLM guide.

What buyers ask

Is a dedicated IAB classifier more accurate than an LLM? No single answer survives the evidence. The one vendor's blind pairwise run had the classifier winning 66 percent of decided pairs. Its gold label multilingual run had the prompted model ahead on top 1, 0.771 against 0.657. Survey work says encoders win pattern driven tasks and LLMs win tasks needing world knowledge. Taxonomy labeling is mostly the first kind. Test both on a sample of your own text. Every public number in this market, on both sides, sits on model judged labels.

Which is cheaper? It depends on the unit, not the rate. A per page lane bills the page count. A prompted model bills input and output tokens, and the category list rides every call. The one public production case measured roughly 2,000 to 3,000 input tokens per call on the prompted path, against about 400 for the constrained path. At corpus scale the shapes diverge fast. The fenced rows and the formulas above price your own shape in one pass.

Which taxonomy version should we emit? 3.1 as the primary, with 2.2 kept for partners that still read it. Set the cattax field on every bid request. An absent cattax silently declares 1.0, the deprecated line. Google's own guide ties default taxonomy use to increased bid filtering. Ask each demand partner what they accept before you re label anything.

Can the LLM produce labels that are not in the taxonomy? Yes, and that cuts both ways. It is the only engine that can label into your own custom segment list. It is also how the benchmark run accumulated 1,796 invented label rows. If the labels feed a bid stream or a safety filter, check every response against the official file. Or use a closed set engine.

Do we still need people in the loop? A confidence floor plus a review queue, yes. Both engines mislabel borderline content. The taxonomy itself lacks per category definitions, and that gap is an open request against the taxonomy owner since July 2026. Review under a floor. Write overrides. Keep the mapping table versioned. The human work is the same whichever engine you pick.

Can we run the classifier ourselves? Yes. The strongest open fine tune is Apache 2.0, covers 35 Tier 1 categories of taxonomy 3.1, and truncates inputs at 1,024 tokens on a base architecture that reads 8,192. Deep tier coverage in open weights is thin today. Weigh that against a hosted lane before committing a corpus.

Last verified: 2026-10-28