API reference
Content feeds (content tokens)
A content token is a pre-configured destination feed — one token_id, one pull URL. Under that single token, one or more keyword rules can be configured, each with its own keywords, content type and brand URLs — all of them queue into the same feed. Each rule gets one new article per week by default, written on a schedule (see Generation schedule). Your integration polls one endpoint, posts whatever it gets back, and then confirms it — pulling content does not mean it was used.
Base URL
https://lexigen.app/api/v1/content-tokens. Every example on this page uses that full URL.How delivery works: reserve, confirm, reject, or auto-abandon
Pulling an item puts it in a reserved state, not a used one. By default, calling the pull endpoint again resends that exact same item — simple, naive polling is always safe and will never silently skip content just because you called twice. There are four ways a reserved item stops being resent:
- Confirm (accept) it — call
POST .../items/{item_id}/confirmafter you’ve actually posted it. This is the only way an item is marked permanently used. - Reject it — call
POST .../items/{item_id}/rejectif you’ve decided not to post it, optionally with areason. This abandons it for good without fetching a replacement in the same call — the next pull call will claim a fresh item. - Reject-and-fetch-next in one call — pass
?next=trueon the pull call itself to do both the rejection and the next claim atomically. Equivalent to calling reject then pulling again, just one round trip. - Auto-abandoned after 3 sends — if the same item gets resent 3 times without ever being confirmed or rejected, the next pull call automatically gives up on it and hands you a new item instead. This is a safety net for a consumer that polls but never confirms, or crashes mid-flow — it requires no action on your part.
Two concurrent or retried calls for the same token can never both claim different unused items out from under each other, nor double-confirm/double-reject the same one — every state transition happens in one atomic database transaction. Each rejection is recorded with its cause, so the feed owner can see who or what rejected an item.
Pull the current (or next) article
/api/v1/content-tokens/{token_id}/latestNo Authorization header is needed — the token_id in the path is itself the secret. Treat your pull URL the same way you’d treat a webhook URL or an API key: don’t share it or commit it to a public repo.
curl https://lexigen.app/api/v1/content-tokens/YOUR_TOKEN_ID/latestQuery parameters
| Field | Type | Description |
|---|---|---|
| next=true | boolean | Reject whatever is currently reserved (cause next_param) and claim the next item in the same call. |
| peek=true | boolean | Return the item a pull would return — the reserved one, else the next unused one in the brand rotation — without reserving it, changing its state or incrementing deliveryCount. The response carries "peek": true. Use it for review or QA tooling; you can’t confirm or reject a peeked item that was never reserved. Ignores next. |
curl "https://lexigen.app/api/v1/content-tokens/YOUR_TOKEN_ID/latest?peek=true"Response — content available
{
"available": true,
"item": {
"id": "cti_a1b2c3",
"post": {
"title": "...",
"slugSuggestion": "...",
"sections": [
"..."
],
"conclusion": "..."
},
"rendered": {
"markdown": "# ...",
"html": "<h1>...</h1>"
},
"generatedAt": "2026-10-05T09:00:00.000Z",
"deliveryCount": 1,
"contentType": "review",
"facts": {
"factSheetId": "ctfs_k2m4p6",
"version": 7,
"brandName": "iD Mobile",
"facts": [
"..."
]
},
"qa": {
"pass": true,
"score": 95,
"gates": [
"..."
],
"claims": [
"..."
]
},
"publisherScript": null
}
}deliveryCount is how many times this exact item has been handed out so far (including this call) — it resets to 1 whenever a new item is claimed, and hits 3 right before the auto-abandon fallback kicks in on the next pull. contentType is the shape the article was written in (review, offers, guide or analysis). facts and qa are described below; both are null on items generated before the facts-first pipeline. publisherScript is your feed’s custom publisher script (see below), or null.
Response — nothing new yet
Still 200 OK — this is a normal, expected response, not an error. It means there’s nothing reserved for you right now and nothing unused is queued — typically because this week’s article has already been consumed. A pull never generates anything, so pulling again sooner does not make an article appear sooner. nextExpectedAt is the best estimate (ISO 8601) of when an item should exist:
- the next scheduled generation of the token’s earliest-due active rule (usually within a week);
- the scheduled retry time when the latest article for a rule was held by quality checks or its run failed;
nullwhen the token is paused or has no active rule — nothing will arrive until the owner changes that.
{
"available": false,
"nextExpectedAt": "2026-10-05T09:04:00.000Z"
}Response — unknown token
{
"error": {
"code": "NOT_FOUND",
"message": "Unknown content token."
}
}Pull everything at once
/api/v1/content-tokens/{token_id}/itemsReturns every pending article on the token in one call (up to 100), across all keyword rules, instead of one at a time. Each article is labeled with ruleId and ruleName and carries the same contentType, facts and qa fields as /latest. Add ?rule=TELLO (rule name, case-insensitive, or rule id) to get only one rule’s articles.
This uses the same lifecycle as /latest: every returned article is reserved and must be confirmed or rejected individually. Calling it again resends the ones you haven’t confirmed or rejected, plus any new ones, and the 3-sends auto-drop applies per article. Both modes share the same state, so you can mix them.
curl "https://lexigen.app/api/v1/content-tokens/YOUR_TOKEN_ID/items?rule=TELLO"{
"count": 1,
"limit": 100,
"items": [
{
"id": "cti_a1b2c3",
"ruleId": "ctkr_x9y8z7",
"ruleName": "TELLO",
"post": {
"title": "..."
},
"rendered": {
"markdown": "# ...",
"html": "<h1>...</h1>"
},
"generatedAt": "2026-10-05T09:00:00.000Z",
"deliveryCount": 1,
"contentType": "offers",
"facts": {
"...": "..."
},
"qa": {
"pass": true,
"score": 100,
"...": "..."
},
"publisherScript": null
}
]
}Confirm an item was posted
/api/v1/content-tokens/{token_id}/items/{item_id}/confirmCall this after you’ve actually published the item returned by the pull endpoint. Same auth model — the token_id in the path is the secret, no body required. Confirming an already-confirmed item is safe and still returns 200 (idempotent). Confirming an item that’s no longer the active reserved one (already superseded by a ?next=true call or the 3-send auto-abandon) returns 409 — there’s nothing left to confirm.
curl -X POST https://lexigen.app/api/v1/content-tokens/YOUR_TOKEN_ID/items/ITEM_ID/confirm{
"ok": true,
"item": {
"id": "cti_a1b2c3",
"status": "used"
}
}Reject an item
/api/v1/content-tokens/{token_id}/items/{item_id}/rejectCall this when you’ve decided not to post the item returned by the pull endpoint — e.g. it doesn’t fit your editorial needs this cycle, or its qa failed. Unlike pulling with ?next=true, this does not fetch a replacement in the same call; it only abandons the current one, and the next pull call claims a fresh item. Same auth model, same idempotency rules as confirm: rejecting an already-rejected item returns 200, rejecting an item that’s already confirmed used (or was never reserved) returns 409.
Optional JSON body { "reason": string } (1–1,000 characters). The reason is stored on the item, shown to the feed owner, and fed back into future generation for that item’s own keyword rule only. Sending no body is fine; any other body shape, or a body over 8 KB, returns 400 VALIDATION_ERROR.
curl -X POST https://lexigen.app/api/v1/content-tokens/YOUR_TOKEN_ID/items/ITEM_ID/reject \
-H "Content-Type: application/json" \
-d '{"reason": "Too salesy — tone it down"}'{
"ok": true,
"item": {
"id": "cti_a1b2c3",
"status": "rejected",
"reason": "Too salesy — tone it down"
}
}reason is echoed only when you sent one.
Rejection causes
Every rejected item records one cause, visible to the feed owner in the dashboard alongside any reason you sent:
| Cause | What happened |
|---|---|
| explicit | Your integration called POST .../reject (with or without a reason). |
| next_param | Your integration pulled with ?next=true while this item was reserved. |
| auto_max_sends | Sent 3 times without a confirm or reject; dropped automatically on the next pull. |
| superseded | The feed owner regenerated the token’s queue; still-open items were retired. Not caused by your integration. |
Only passing articles are delivered
A feed only ever delivers articles that passed every blocking quality check (qa.pass: true). An article that still fails a blocking gate is held: it is never queued, so no pull, peek or bulk request can return it. Held articles retry automatically:
- Contradicted claims are always removed. Any sentence that contradicts the fact sheet is cut before the item is stored, and unsupported sentences are removed too. Removed sentences are listed in
qa.claimswithomitted: true. - If blocking quality gates still fail, deterministic fixes are applied and at most one targeted repair pass runs within the same cycle, using the same facts.
- If it still fails (e.g. too few sourced figures, or no fact sheet because the rule has no brand URL), the article is held. A held article is never deleted from view for the owner and never delivered; the scheduler retries the rule once later, and otherwise the rule’s next scheduled cycle writes a new one. Pulls never trigger a retry. The feed owner sees the article status, the failure reason and the retry time on the rule in the dashboard.
- Any previously queued, still-unused article for that rule stays available while a new one is held.
- While no passing article is ready, a pull returns
available: falsewithnextExpectedAt, never a failing article.
Every delivered item still carries its full qa object. Items stored before this gate existed may have qa.pass: false, so a defensive integration can keep checking it (or a minimum qa.score) and reject anything below its bar, ideally with a reason:
const res = await fetch(`https://lexigen.app/api/v1/content-tokens/${TOKEN_ID}/latest`);
const body = await res.json();
if (body.available) {
const { item } = body;
if (!item.qa || !item.qa.pass) {
const failed = (item.qa?.gates ?? []).filter((g) => !g.pass).map((g) => g.name);
await fetch(`https://lexigen.app/api/v1/content-tokens/${TOKEN_ID}/items/${item.id}/reject`, {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({ reason: `auto-rejected: failed ${failed.join(", ")}` }),
});
} else {
await publish(item.rendered.html);
await fetch(`https://lexigen.app/api/v1/content-tokens/${TOKEN_ID}/items/${item.id}/confirm`, { method: "POST" });
}
}The facts object
The exact fact-sheet version the article was written from, so you can audit every claim. Facts come from the rule’s own brand pages (read directly, restricted to the configured hosts) and, for promotions and launches only, dated news articles. Every fact’s quote is verified to appear verbatim in the fetched page before it’s kept.
| Field | Type | Description |
|---|---|---|
| factSheetId | string | Id of the stored fact-sheet version. |
| version | number | Fact-sheet version for this rule (increments on each fetch). |
| builtAt | string (ISO 8601) | When this version was built. |
| brandName | string | The brand, with the casing used on its own site. |
| facts[] | Fact[] | Facts about the main brand — fields below. |
| sources[] | Source[] | Every page fetched for the main brand, including failures. |
| alternatives[] | { brandName, facts[] }[] | Facts for up to four alternative brands (review comparisons). |
| reference | object (optional) | Verified reference facts from allowlisted authoritative sources (regulators, statistics offices, filings, trade bodies): facts[], publishers[], sufficient (at least 5 facts from at least 3 publishers). |
Fact
| Field | Type | Description |
|---|---|---|
| id | string | Stable within one version: F1, F2, … Cited by qa.claims[].citedFactIds. |
| brand | string | Which brand the fact is about. |
| category | string | plan, price, inclusion, network, support, contract, cancellation, returns, shipping, promotion, product, company, launch, development, market, statistic, survey, forecast, regulation or other. |
| statement | string | Short canonical statement used for writing and claim checking. |
| value | string | null | The specific value, e.g. £10/mo, 30 days. |
| quote | string | Verbatim text from the source page. |
| sourceUrl | string | Page the quote came from. |
| sourceKind | string | official (brand’s own pages), news (dated article, secondary) or reference (allowlisted authoritative source). |
| fetchedAt | string (ISO 8601) | When the source was retrieved. |
| publishedAt | string | null | News: the article's publication time. Reference: the date the page states, if any. |
| publisher | string | null (optional) | Reference: the source's publisher from the allowlist. News statistics: the organisation the quote names. |
| dataYear | number | null (optional) | Reference only — the latest past year the quote mentions. |
| maxAgeDays | number | null (optional) | Reference only — the age limit the fact was checked against. |
| expiresAt | string | null | Promotions only — after this date the fact is ignored. |
| offer | object | null | Structured plan/promotion: name, namedInSource, price, period, inclusions[], term, kind (plan | promotion). |
Source
| Field | Type | Description |
|---|---|---|
| url | string | Fetched URL. |
| kind | string | official or news. |
| method | string | Opaque identifier for how the page was retrieved (an official-page read or a news lookup). Informational only; don't build logic on its value. |
| status | string | ok or error (blocked, timed out, …). |
| error | string? | Why the fetch failed, when status is error. |
| fetchedAt / title / chars / publishedAt | optional | Retrieval time, page title, fetched length, article date. |
{
"factSheetId": "ctfs_k2m4p6",
"version": 7,
"builtAt": "2026-10-05T08:58:12.000Z",
"brandName": "iD Mobile",
"facts": [
{
"id": "F1",
"brand": "iD Mobile",
"category": "price",
"statement": "The 100GB SIM-only plan costs £10 a month on a 24-month contract.",
"value": "£10/mo",
"quote": "100GB data £10 a month 24 month plan",
"sourceUrl": "https://www.idmobile.co.uk/sim-only-deals",
"sourceKind": "official",
"fetchedAt": "2026-10-05T08:57:40.000Z",
"publishedAt": null,
"expiresAt": null,
"offer": {
"name": "100GB SIM only",
"namedInSource": true,
"price": "£10",
"period": "month",
"inclusions": [
"100GB data",
"unlimited minutes and texts"
],
"term": "24 months",
"kind": "plan"
}
}
],
"sources": [
{
"url": "https://www.idmobile.co.uk/sim-only-deals",
"kind": "official",
"method": "<retrieval method>",
"status": "ok",
"fetchedAt": "2026-10-05T08:57:40.000Z",
"title": "SIM Only Deals | iD Mobile",
"chars": 18342
}
],
"alternatives": [
{
"brandName": "giffgaff",
"facts": []
}
]
}The qa object
The quality report for the shipped article: an overall verdict, every gate result, and every factual claim with its label.
| Field | Type | Description |
|---|---|---|
| qaVersion | string | Version of the QA rules, currently lexigen-qa-1. |
| pass | boolean | true when every blocking gate passed. The field to auto-reject on. |
| score | number (0–100) | 100 minus 20 per failed blocking gate, 5 per failed soft gate, 3 per unsupported and 10 per contradicted published claim. For threshold-based auto-reject. |
| contentType | string | Shape actually written: review, offers, guide or analysis. |
| requestedContentType | string | Shape the rule asked for. Differs when an offers rule fell back to review because the facts held no offers, or an analysis fell back to review because the verified reference facts were insufficient. |
| wordCount | number | Words in the published article. |
| metrics | object | Raw measurements: hedge words (and per 1,000 words), keyword and brand occurrences/density/max per paragraph, concrete sourced figures, claim counts, verdictPresent, brandCasingViolations[]. |
| gates[] | Gate[] | Each gate: name, pass, blocking, and optional value, threshold, detail. |
| claims[] | Claim[] | Each claim: id, text, location (e.g. s2.p1), citedFactIds[], label (supported | unsupported | contradicted), optional reason, and omitted: true when it was removed from the article. |
| fixes[] | string[] | Deterministic fixes applied (sentences removed, brand casing corrected, …). |
| factSheet | object | mode (facts | no_facts), version, factSheetId, fact counts by source, newsFallback, fallbackUsed + fallbackAgeHours (this run’s fetch failed and an earlier sheet was used), fetchErrors[]. |
| attempts | number | Draft calls made for this article (1 + redrafts), a failed call included. |
| draftsRun | number | Same as attempts (explicit name; absent on older items). |
| bestAttempt | number | Which draft (1-based) the delivered article came from (absent on older items). |
| warnings[] | { code, message }[] | Non-blocking issues for the feed owner. code is one of no_brand_url, fetch_failed_fallback (an earlier fact sheet was used), fetch_failed_no_facts (general article) or analysis_insufficient_reference (an analysis needs at least 5 verified reference facts from at least 3 publishers; a review was written instead, never a padded analysis); message is human-readable. |
| feedbackApplied[] | string[] | Recent reject reasons for this rule that were fed into generation. |
Gates
Blocking unless noted. Which gates appear depends on the content type and whether a fact sheet was available.
| Field | Type | Description |
|---|---|---|
| facts.available | blocking | A fact sheet was available. Fails for a general article (no brand URL, or fetch failed with nothing to fall back to). |
| body.present | blocking | The article has body text (fails only if removing claims left nothing). |
| claims.contradicted | blocking | No published claim contradicts the facts (threshold 0). |
| claims.unsupported | blocking | At most 2 published claims lack a supporting fact. |
| hedges.per1000 | blocking | At most 8 hedge words per 1,000 words. |
| keyword.density / keyword.perParagraph | blocking | Keyword at most 0.8% of words and once per paragraph. |
| keyword.present | soft | The keyword appears at least once (body or title). |
| openers.boilerplate | blocking | No stock filler openers. |
| title.recycled | blocking | Title isn't a near-repeat of the rule's recent titles. |
| brand.density / brand.perParagraph / brand.casing | blocking | Review and offers: brand at most 1.8% of words, at most twice in a paragraph of 60+ words and once in shorter paragraphs and list items. Analysis: 1.0% and once per paragraph. Guide: 0.8% and once per paragraph. Always in the brand's own casing. |
| brand.headings | blocking | At most half of the section headings name the brand. |
| brand.share | blocking | Analysis with alternatives: the rule's brand is at most 40% of all brand mentions (its own plus the alternatives'). |
| figures.sourced | blocking | With facts: at least 5 concrete figures traceable to the fact sheet. |
| shape.verdict | blocking | Review and offers: a clear verdict is present. |
| shape.structure | blocking | The article follows its content type's section structure. |
| shape.sources | blocking | Analysis: the Sources list holds at least 5 pages from at least 3 publishers (reference publishers and each brand's own site), and the reference sheet is sufficient. |
| shape.alternatives | soft | Review: at least 2 alternatives are compared (up to 4 can be configured). |
| length.target | soft | Body length within the shape's target (review 1,400–1,900, offers 1,100–1,500, guide 1,500–2,200, analysis 1,800–2,600 words), scaled down to 55 words per usable fact — never padded. |
| facts.coverage | soft | At least 70% of the fact sheet is cited by published claims. |
| facts.perSection | soft | Every writer-led section cites at least 2 different facts. |
| readability | soft | Flesch reading ease near the shape's target (55–65 for review, offers and guide; 45–55 for analysis, written in the third person) and sentences of about 14–18 words. |
| title.shapeMatch | soft | The title reads like its content type (e.g. a review isn't titled like a deals page). |
| rating.variance | soft | Review and offers: 4–5 scorecard criteria survive the claim check and their scores are not all the same. |
{
"qaVersion": "lexigen-qa-1",
"contentType": "review",
"requestedContentType": "review",
"pass": true,
"score": 94,
"wordCount": 1184,
"metrics": {
"hedgeWords": 6,
"hedgePer1000": 5.07,
"keywordPhrase": "id mobile review",
"keywordOccurrences": 4,
"keywordDensityPct": 0.34,
"keywordMaxPerParagraph": 1,
"brandName": "iD Mobile",
"brandOccurrences": 9,
"brandDensityPct": 0.76,
"brandMaxPerParagraph": 1,
"concreteFigures": 6,
"claims": {
"total": 23,
"supported": 19,
"unsupported": 2,
"contradicted": 0,
"omitted": 2
},
"verdictPresent": true,
"brandCasingViolations": []
},
"gates": [
{
"name": "claims.contradicted",
"pass": true,
"blocking": true,
"value": 0,
"threshold": 0
},
{
"name": "figures.sourced",
"pass": true,
"blocking": true,
"value": 6,
"threshold": 5
},
{
"name": "shape.alternatives",
"pass": true,
"blocking": false,
"value": 2,
"threshold": 2
}
],
"claims": [
{
"id": "C1",
"text": "The 100GB plan is £10 a month on a 24-month contract.",
"location": "s1.p2",
"citedFactIds": [
"F1"
],
"label": "supported"
},
{
"id": "C22",
"text": "iD Mobile has the fastest 5G in the UK.",
"location": "s3.p1",
"citedFactIds": [],
"label": "unsupported",
"reason": "no fact covers network speed rankings",
"omitted": true
}
],
"fixes": [
"removed 2 unsupported sentences"
],
"factSheet": {
"mode": "facts",
"version": 7,
"factSheetId": "ctfs_k2m4p6",
"factsFromOfficial": 14,
"factsFromNews": 0,
"droppedQuoteMismatch": 1,
"newsProviders": {},
"newsFallback": true,
"fallbackUsed": false,
"fallbackAgeHours": null,
"fetchErrors": []
},
"attempts": 2,
"draftsRun": 2,
"bestAttempt": 2,
"warnings": [],
"feedbackApplied": [
"Too salesy — tone it down"
]
}The publisherScript field
A feed owner can attach a custom publisher script to a token — typically a partner snippet such as a Skimlinks or analytics <script> tag. Every item delivered for that token (/latest, ?peek=true, resends and /items) carries it as item.publisherScript: a string returned exactly as configured, byte for byte.
- Always present. It is
nullwhen the feed has no script configured. - It is never part of
rendered.htmlorrendered.markdown— the article body is unchanged whether or not a script is set. - Inject it once per page (not once per section or per article on a listing page), e.g. immediately before
</body>. - Lexigen treats it as opaque data: it is returned as a JSON string and is never rendered, executed or validated as code by Lexigen. Whatever your page does with it runs on your site, under your own Content-Security-Policy.
{
"available": true,
"item": {
"id": "cti_a1b2c3",
"...": "...",
"publisherScript": "<script type=\"text/javascript\" src=\"https://s.skimresources.com/js/000000X000000.skimlinks.js\"></script>"
}
}const res = await fetch(`https://lexigen.app/api/v1/content-tokens/${TOKEN_ID}/latest`);
const body = await res.json();
if (body.available) {
const { item } = body;
// Article body: rendered.html never contains the publisher script.
let page = renderTemplate({ title: item.post.title, body: item.rendered.html });
// Inject the feed's script ONCE per page, just before </body>. A function
// replacer keeps "$&"-style sequences in the script literal.
if (item.publisherScript) {
page = page.replace("</body>", () => `${item.publisherScript}\n</body>`);
}
await publish(page);
}Polling guidance
New articles arrive about once a week per keyword rule, so polling a few times a day (e.g. every 2–6 hours) is plenty to pick up new content promptly. Polling more often never produces content faster. When a pull returns available: false, waiting until nextExpectedAt is a good default. There’s no rate limit tied to a customer plan here — this is an internal delivery feed, not the metered /v1/generate//v1/jobs API — but please still poll reasonably, not in a tight loop, and confirm or reject once you’re done with an item rather than relying on the 3-send fallback as your normal flow.
How content is generated
Content-token articles are written facts first. For each run of a keyword rule:
- The rule’s brand URLs (its official URLs plus its offer URLs) are read, restricted to exactly those hosts, and a versioned fact sheet is built — every fact with a verbatim quote, source URL and fetch time. If the fetch fails after one retry, the previous good sheet is used (recorded in
qa.factSheet.fallbackUsed). A rule with no brand URL writes a general article that fails thefacts.availablegate. - One draft call writes the article in the rule’s content type from those facts only.
- Every factual sentence is checked against the sheet; contradicted and unsupported sentences are removed, brand casing and keyword density are fixed, then the gates run — with at most one targeted repair pass if blocking gates fail.
Fact sheets are reused between cycles while the brand’s pages are unchanged; they are re-read only when a source page changes or the sheet reaches its maximum age.
Article structure
Review and offers articles open with a verdict and an At a glance card: who it is best for, the starting price and 3–5 key details, all built from verified facts. Then come Key takeaways (3–5 bullets, each tied to a fact; the box is left out if fewer than 3 survive the claim check), pros and cons, the body sections (reviews include a features section with an H3 per feature), the pricing table, who it’s for, alternatives, a scorecard and the final verdict, then the FAQ. The scorecard rates 4–5 fixed criteria for the vertical from 1 to 5, each with a reason citing a fact; the overall rating is their mean, recomputed after the claim check. Guides have takeaways, sections and a bottom line.
When alternatives are configured, the alternatives section carries a comparison table: the rule’s brand against up to four alternatives on fixed rows (starting price, contract, inclusions, returns or cancellation, delivery, support, network). A row appears only when the rule’s brand and at least one alternative have a verified fact for it; a missing cell is “—”; every cell is a fact’s value or statement, never model text; a caption names the sources. With no alternatives, or fewer than two rows, there is no table.
Analysis (contentType: "analysis") is a data-led, third-person piece: a stat-first intro, Key takeaways, then Market size, Key drivers, Segments, Regional picture, Competitive landscape, Challenges, Outlook and What this means, then the FAQ, Sources and the research note. Sections the facts don’t cover are left out. The landscape has one short card per brand (the rule’s brand and its alternatives, alphabetically, built only from their fact sheets) and the comparison table; the rule’s brand gets no special place. When a published sentence cites a forecast or survey figure, a fixed Note on estimates callout is added (aside.lexigen-note in HTML, a quote in markdown). An analysis has no At a glance card and at most one CTA (in What this means, else after the landscape). It needs verified reference facts — at least 5 from at least 3 publishers — or the rule falls back to a review with the analysis_insufficient_reference warning. An optional focus on the rule’s request picks the variant: landscape (default, the market as a whole) or company (the brand itself, from filings and investor-relations pages).
Charts. Up to three deterministic charts are drawn from verified fact values only: a price ladder of the brand’s plans (after Pricing), one attribute such as starting price across at least three brands (after the alternatives or the landscape), and one publisher’s metric across at least three years (analysis, after Market size). A value that is a range, a bound (“up to”, “60+”) or otherwise ambiguous is never charted, and a chart without enough clean values is left out. In rendered.html a chart is a figure.lexigen-chart with an inline <svg role="img"> (aria-label, title, explicit fills, no <style> element) and a “Source: …” caption; rendered.markdown gets the same data as a small table.
Every article with facts ends with a Sources list (the pages behind the published claims, with the publisher’s name for reference sources) and a short How this article was researched note (pages read, the date, facts kept, statements removed). Both are generated from the fact sheet and the claim check, never written by the model, and the note never claims hands-on testing. A byline appears only when the rule configures an author ({ name, role? }). The Sources list and byline appear only in rendered.html/rendered.markdown; the research note is also part of post.conclusion.
Offer & brand links
A keyword rule can carry a list of offers/brands, each with a link. Linking is deliberately light: in each H2 section only the first mention of the brand name is hyperlinked to the rule’s brand URL (the offer whose label is the brand, e.g. “Theory UK” for Theory), and the first mention of a specific offer by its label links to that offer’s own URL. Headings (the title and every subheading) are never linked, and neither are the Sources list and the research note. Any offer whose link never appears in the article is added to a short “Featured offers” list at the end, so every configured link appears at least once. Offer URLs also count as brand URLs for fact fetching.
CTAs. An article has at most three call-to-action buttons (an analysis at most one, in What this means): one closing the At a glance card (or the first section, if there is no card), one after the pricing section, and one in the final verdict or bottom line. The FAQ, “Featured offers”, Sources and sections about alternatives/competitors never get one. Its link is always a verified URL: an offer URL or official URL configured on the rule (used exactly as configured), or a page on the brand’s own domain (subdomains included) that a fact in the item’s fact sheet was read from. Per section it is the offer the section names, else the brand page the section’s facts were read from (e.g. the returns page), else the brand’s main URL. News, reference, alternative-brand and other URLs are never used; with no verified URL there is no CTA. The button text is short and claim-free (e.g. “Read Theory’s returns policy”, “Visit Tello”). CTAs count as links for the “Featured offers” list.
Affiliate disclosure. Whenever the article contains a sponsored link, a fixed disclosure line is added under the title and again just before the first CTA: “This article contains affiliate links; we may earn a commission if you buy through them, at no extra cost to you.” In rendered.html it is <p class="affiliate-disclosure">.
- Links appear in
rendered.htmlandrendered.markdown. The structuredpostJSON stays link-free. - In
rendered.html, brand, offer and CTA links carryrel="sponsored noopener"and open in a new tab, as Google requires for affiliate/paid links; Sources links carryrel="noopener". Markdown can’t expressrel— if you publish fromrendered.markdown, addrel="sponsored"to brand/offer/CTA links in your own renderer. - Only the configured URLs and the fact sheet’s own source pages can ever appear — the generator itself never writes links.
- Links are never nested and never placed inside an existing link, code, or a heading.
- In
rendered.htmla CTA is<p class="cta"><a class="cta-button" rel="sponsored noopener" target="_blank">with an inline button style (so it still looks like a button if your CMS strips<style>); restyle it with the.cta-buttonclass. Inrendered.markdownit is a standalone[Label →](url)line. A CTA is never placed inside a list or table, and a section never gets two. The At a glance card, Key takeaways and scorecard are wrapped indiv.lexigen-glance,div.lexigen-takeawaysanddiv.lexigen-scorecardfor styling.
Configuration
Tokens and their keyword rules are configured by the Lexigen team. There is no public endpoint to create or modify one. Each rule has its own keywords, generation interval, content type (review, offers, guide or analysis, with an optional analysis focus), vertical, site persona, market, brand name, official URLs, up to four alternative brands and offer links; a token can set defaults that apply only to rules that leave a setting blank. Pausing a rule stops just that keyword group, while pausing the token itself stops every rule under it (already-queued items remain pullable either way). If you need a new feed, an additional keyword group, or a settings change, just ask.
Generation schedule
- Weekly, per rule. Each keyword rule generates one new article per cycle. A cycle is 7 days by default; the feed owner can shorten it (down to 1 day) only for genuinely time-sensitive topics. The scheduler runs once a day, at 09:00 UTC and generates for every rule whose cycle is due.
- Pulls never generate. Pull, peek, bulk, confirm and reject only read and update the queue; none of them starts a generation or a fact refresh.
- When this week’s article is consumed, the pull returns the documented empty state (
{ "available": false, "nextExpectedAt": … }) until the rule’s next cycle. - Held articles are retried by the scheduler, not by pulls: one controlled retry, then the next regular cycle.
None of the response contracts on this page change with the schedule: the same fields, status codes, idempotency and delivery rules apply.