Simple API to audit, screen and flag users based on age. Our AI analyzes writing samples and chat data to instantly return age predictions. Trained on hundreds of thousands of writers. Test for free and pay only for what you use.
1–2¢
per call
90%+
accuracy
Trained on
200,000+
writers
1.6B
messages
The mechanism differs from identity-verification services. Three properties follow from inferring age from writing instead of documents.
The API reads writing the user produces for other reasons — chat messages, bios, posts. It does not require the user to upload, photograph, or confirm anything.
No ID. No selfie. No PII.
Identity-verification services check at signup and return a single boolean. This API can be called on every message, so confidence accumulates across a user's history as more text becomes available.
Single signal, repeatable.
The model was trained on SMS but the features it learned — vocabulary, sentence structure, punctuation, idioms — generalize to any user-written text: human chat, AI chat, email, forum posts, bios, support tickets.
Any text the user wrote.
Paste a sample of writing — a chat message, email, or forum post — and see the verdict, confidence score, and the signals the demo flagged.
Live API
free tierFree tier — 10/hr, 50/day per IP
Quick samples:
Age verification comes in two shapes, built for two different jobs. ID-and-selfie verification — Yoti, Persona, Veriff — is the established approach: a one-time check of a government ID and a selfie at signup. Strong, definitive evidence, and the right tool for high-trust moments like opening a bank account. But age assurance on consumer chat, AI, and social platforms is a different problem — ongoing, high-volume, often with no signup ID step at all, and document-upload flows shed 30–50% of users at the verification screen. That's where text-based inference fits: it reads how a user writes — passively, continuously, no upload, no document, no PII — and keeps reading as the conversation goes.
Identity verification (Yoti / Persona / Veriff)
Text-based inference (this API)
Feature by feature, against the ID-verification vendors. Different tools for different jobs — text-based inference is built to run alongside ID verification, not replace it.
| Our API | Yoti | Persona | Veriff | |
|---|---|---|---|---|
| Detection method | Writing-style ML | ID + selfie | ID + selfie + db | ID + selfie |
| User friction | None — passive | High — upload flow | High — upload flow | High — upload flow |
| PII collected | None | Photo ID + biometric | Photo ID + biometric | Photo ID + biometric |
| Cost per check | $0.01–$0.02 | $0.10–0.50 | $0.10–0.40 | $0.20–1.50 |
| Speed | Instant — no user action | Minutes of user effort | Minutes of user effort | Minutes of user effort |
| Continuous monitoring | Yes — every message | No | No | No |
| Works in chat / SMS / AI products | Yes | Needs webview | Needs webview | Needs webview |
| Catches account handoffs | Yes | No | No | No |
| Regulator-recognized | As supplementary signal | As primary | As primary | As primary |
| Best used as | Pre-gate + background | Fallback for flagged | Fallback for flagged | Fallback for flagged |
Each row is a property of the deployment mechanism, not a value judgment. Different deployments call for different tools.
Building an age gate that actually works has been an insidiously hard problem for consumer digital services — and AI products inherit it in full. Traditional age gating gives you two options, and both are bad.
A date-of-birth field or an “I'm over 18” checkbox. Frictionless, but meaningless — the users you most need to catch are exactly the ones who will lie.
Government ID and a selfie. It works, but it's slow, expensive, and turns away the 99%+ of users who are perfectly allowed to be there. Friction that heavy doesn't protect your product; it shrinks it.
The middle path. Estimate age in real time from text the user already produces — no upload, no document, no PII. Audit your existing users, and adapt or gate content live until age confidence is high enough. The user never has to know they were checked.
Not just a gate — a live signal
Because it reads each session as it happens and works on small samples, you can do more than block — you can adapt content in real time. An adult and a minor sharing one login — a kid on a parent's account — get different experiences in different sessions: the full product for the adult, a safer one the moment a session starts reading younger. That's the exact case ID verification, which only ever checks the account once at signup, structurally cannot see.
As AI products go mainstream and regulation tightens, every provider will have to answer “do you know who's using this?” — without wrecking the experience for the overwhelming majority who are fine. A quiet, always-on layer of age confidence adds compliance and effort without adding friction. This is how you get ahead of it.
Any text the user produces — bio at signup, first chat messages, AI conversation, support ticket. The text needs no preparation beyond what is normally collected.
Send the text. The API returns a verdict (over_18 / under_18 / uncertain), a confidence score, a predicted age range, and a decision_id for your audit trail.
Users with a clear over_18 verdict complete the flow without further checks. The threshold for what counts as "clear" is configurable per integration.
Users flagged under_18 — or uncertain at the threshold you set — are routed to your existing identity-verification vendor for the stronger check. The decision_id forms part of the audit chain.
Call the endpoint on subsequent messages and compare verdicts over time. This surfaces account handoffs and behavioral drift long after the initial check.
Cost arithmetic
On the validation set, the text-based gate clears the majority of adults at high confidence. If identity verification is reserved for the flagged subset, the per-signup spend at a representative ID rate of $0.30 falls from $0.30 to $0.02 (text gate) + $0.018 (ID on the flagged 6%) ≈ $0.04. The result is a reduction in ID-verification cost; it is not a replacement.
Categories where text-based age inference fits the deployment surface. Each has different latency, cost, and accuracy requirements.
ChatGPT-style products with no signup ID flow. Bulk-scan your existing conversation logs to retroactively flag minors, then run on new messages to catch them before sensitive content is generated.
Adult-only platforms facing Ofcom OFA-1 and payment-processor (Fibonatix, etc.) age-assurance demands. Our API + ID-fallback satisfies the layered-assurance test.
Match, Bumble, Hinge — our model monitors continuously to catch underage users who pass initial age gates with a parent's ID.
KOSA-relevant platforms (TikTok, Discord, Snapchat). The classifier runs on every post and DM, detecting age drift and account handoff.
Roblox, Steam — minor protections at scale. The model reads in-game chat passively to flag accounts inconsistent with claimed age.
Carriers running AI on subscriber SMS. Works on raw SMS — no webview required for ID upload.
If you run an AI chatbot, the record of who has been talking to it is already sitting in your logs. The same model that gates new messages can read your existing transcripts and tell you which ones came from minors.
Step 1 — one-time backfill
Run your stored conversations through the API in a single bulk pass. It retroactively flags the users and threads most likely to be minors — turning an unknown compliance exposure into a concrete, auditable list. No re-architecture and no new data collection: it reads the text you already have.
Step 2 — ongoing gate
The same endpoint runs on new messages as they arrive. Suspected minors are flagged as they write — before sensitive content is generated — and the signal strengthens across the conversation. One integration covers both your backlog and your live traffic.
Why now: Ofcom's OFA-1, KOSA, and OpenAI's own age-prediction work have made “do you know who is using your bot?” a board-level question. Bulk backfills get volume pricing — talk to us about scanning at scale.
Held-out evaluation of the live v2 model against 3,400+ users with confirmed self-reported ages — retrained on 17,000+ users, roughly doubling minor recall versus the prior model.
94%
Specificity — legitimate adults pass invisibly
67%
Minor recall — up from 44% in the prior model
91%
Precision on minor flags
These are single-shot numbers — one message, one verdict — from the live v2 model, retrained on 17,000+ users with confirmed ages (which roughly doubled minor recall vs the prior model). The signal compounds with use: across five or more messages from the same user, the effective false-positive rate falls below 1%.
Most published stylometric age-inference work uses snapshot datasets — Twitter dumps, blog corpora, forum scrapes. These capture how different individuals at different ages wrote during a single time window; they support cross-sectional comparison but not within-person modeling.
This corpus is constructed differently. A consumer messaging app, with explicit user consent, uploaded each user's entire SMS history. For a user who installed at age 25, the dataset contains their messages from age 15, 17, 20, 23 — bound to one identity.
Two consequences. First, the classifier can be trained on within-person age progression rather than cross-sectional age class, which separates writing-style variance from individual style. Second, validation pairs are stronger: more than 17,000 confirmed self-reported ages cross-referenced against the user's longitudinal text record.
Why this works
A single endpoint, POST JSON in and JSON out. Authentication via bearer token in the Authorization header.
POST /api/v1/age-gate
curl -X POST https://www.textmei.com/api/v1/age-gate \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"text": "hey lol ikr that movie was so cringe my mom wont let me go out tonight 😭"
}'Response (HTTP 200)
{
"verdict": "under_18",
"confidence": 0.87,
"predicted_age_range": "14-17",
"model_version": "age-v2",
"decision_id": "agd_01HZK4PYR2X9JFQ8N4C0M",
"ms": 142,
"tier": "free"
}Request fields
Verdict values
Billing
Continuous monitoring — recommended pattern
Call the endpoint on every meaningful user-written message (initial signup form, first 5–10 chat messages, periodic re-checks) and aggregate verdicts per user on your side. The signal compounds: one careful message can fool a classifier, but a user's natural style reasserts itself across messages two, three, and four.
Server-side rolling confidence per user is on the roadmap. Talk to us about high-volume integration.
Text is processed in-memory and discarded post-classification. No raw text retained. No biometric data ever.
Every classification gets a unique decision_id. Logs are retained for audit and exportable for regulator review.
All API traffic and stored data encrypted, hosted on SOC2-compliant infrastructure.
API keys can be scoped per environment, rotated on demand, and revoked instantly. Per-key rate limits and per-key usage analytics.
For high-compliance customers: even decision_ids stripped. Suitable for GDPR Article 17 / CCPA right-to-delete workflows by default.
Status page and email incident reports. Enterprise customers get a production SLA and a named on-call contact.
A free tier rate-limited per source IP for evaluation, a usage-based tier for production deployment, and a custom tier for higher volume.
Free
No signup required
Pay-as-you-go
Drops to $0.01/call after 100K lifetime
Skip the $0.02 ramp. $1,000 = 100,000 calls at the locked rate.
Enterprise
For 1M+ calls/mo or contract terms
All tiers run the same production model. Pay-as-you-go and Free share one API; the only differences are rate limit and billing.
It's a smarter age gate — but it works differently. A traditional age gate is a one-time wall at signup (a date-of-birth field or an ID check) that either lets users lie or turns most of them away. This API is a passive, continuous age gate: it reads how a user writes on every message, so you can gate, limit, or differentiate content in real time without asking for a document. Most teams run it as the front-line gate and keep an ID vendor as the fallback for flagged users.
Those are ID-verification services — they require government documents, selfies, and a one-time check at signup. This API is fundamentally different: a passive, continuous classifier reading writing style. No ID, no selfie, no PII. Runs on every message, not just signup. Best paired with an ID vendor as the fallback for flagged users.
Anything the user wrote: chat (with humans or with AI), email, signup bios, customer-service tickets, forum posts, in-app comments. Trained on SMS but generalizes broadly because the model learns vocabulary and stylistic patterns that hold across channels.
You call the endpoint on every meaningful message and compare verdicts over time on your side. Because the read is per-message, you can catch account handoffs (a minor on a parent's verified account), age drift, and inconsistencies between claimed age and actual behavior — things a one-shot signup check can never see. Server-side rolling confidence per user is on the roadmap.
Its standout property is specificity — about 94% of genuine adults pass through invisibly, so you're not adding friction for the people who don't need it. The live v2 model (retrained on 17,000+ users with confirmed ages) roughly doubled minor recall to ~67% versus the prior model. Accuracy compounds with continuous use: across five or more messages from the same user, the effective false-positive rate drops below 1%.
Best used as one layer in a layered age-assurance stack — the regulator-recognized pattern. Pair this API (passive pre-gate) with an ID-verification vendor (fallback for flagged users) plus full audit logs to meet meaningful-effort tests across all four jurisdictions.
Processed in-memory, not persisted by default. Hashed decision IDs are retained for audit. Enterprise customers can opt for zero-retention mode where no record of input text exists post-classification.
Yes. Because you can run it across many messages, it's resistant to one-shot deception — a 14-year-old typing one careful adult-sounding sentence reverts to their natural style across messages two, three, four. Aggregate the verdicts and the truth surfaces. Single-shot evasion here is much harder than evading ID-based vendors with a parent's documents.
It's live now. The free tier (rate-limited, no signup) is callable immediately, and paid API keys are emailed instantly after checkout. The model was just upgraded to v2 (retrained on 17,000+ users); all keys use it automatically.
Two ways. (1) The browser demo above runs a lightweight version of the classifier client-side — paste in any text. (2) The Free tier on the API is IP-rate-limited (10/hour, 50/day per IP) and requires no signup or credit card — just hit the endpoint from your terminal. Same model, same response shape as paid tiers.
Each API key has a lifetime call counter. The first 100,000 calls bill at $0.02 each from your prepaid balance. After 100,000, all subsequent calls bill at $0.01 — permanently, no monthly reset. If you'd rather skip the ramp, the $1,000 prepay starts you on $0.01 immediately and credits $1,000 toward calls. Heavier usage moves to a custom enterprise rate below $0.01.