Inferensys

Prompt

Children's Data (COPPA) Risk Detection Prompt

A practical prompt playbook for using Children's Data (COPPA) Risk Detection Prompt in production AI workflows.
Risk analyst performing AI risk assessment on laptop, risk matrices visible, casual office risk session.
PROMPT PLAYBOOK

When to Use This Prompt

Understand the specific job this prompt performs, the required context for safe operation, and the hard boundaries where it should not be applied.

This prompt is an ingress classifier for platform safety teams and edtech compliance engineers who must detect indicators of under-13 user data, child-directed content, and age-gating bypass attempts before user-generated content enters downstream processing, storage, or AI model training pipelines. The job-to-be-done is structured risk detection, not automated enforcement. The prompt inspects text input for signals that trigger COPPA obligations: explicit age statements, school grade references, child-directed language patterns, and attempts to circumvent age verification. The output is a structured risk assessment that routes to human review queues and parental consent verification workflows. The ideal user is an engineer integrating this prompt into a data ingestion pipeline where COPPA compliance is a legal requirement, not a feature request.

Use this prompt when you need a deterministic, auditable detection layer that sits before any persistent storage or model training step. It is appropriate for user-generated content platforms, educational technology products, and any service where under-13 data collection triggers regulatory obligations. The prompt requires the following context to function safely: a clear definition of what constitutes child-directed content in your specific product, a pre-defined routing map for each risk level the prompt outputs, and a human review queue that can act on HIGH risk classifications within your compliance window. Do not use this prompt as a standalone age verification system, as a substitute for legal advice, or as the sole mechanism for blocking under-13 users. It is a detection layer that must feed into a broader compliance program with human oversight, audit trails, and documented procedures.

Before deploying this prompt, ensure you have instrumented your pipeline to log every classification result with the original input, the model's confidence score, and the routing decision. This audit trail is essential for demonstrating reasonable compliance practices to regulators. The prompt is designed to err toward false positives—flagging content for human review rather than letting potential under-13 data pass silently. If your operational capacity for human review is constrained, adjust the [RISK_LEVEL] thresholds in the template to match your team's review bandwidth, but document the trade-off explicitly. Never route HIGH risk classifications directly to automated rejection without human confirmation, as this creates a risk of wrongfully blocking legitimate users and losing the audit evidence that regulators expect.

PRACTICAL GUARDRAILS

Use Case Fit

Where the Children's Data (COPPA) Risk Detection Prompt works and where it introduces unacceptable risk. This prompt is a triage classifier, not a compliance determination engine.

01

Good Fit: Pre-Processing Ingress Filter

Use when: you need to screen user-generated text, profile bios, or chat messages before storage or downstream processing. Guardrail: Deploy as a synchronous check in your API gateway or ingestion pipeline. Route flagged content to a quarantine queue and never persist un-reviewed under-13 indicators.

02

Good Fit: EdTech Platform Age-Gating

Use when: a student types free-text in a signup flow, learning module, or chat feature that could reveal age. Guardrail: Combine with session-level context. A single "I am 10" message triggers review, but repeated signals across a session should escalate priority and lock the session until verified.

03

Bad Fit: Sole Compliance Verdict

Avoid when: you need a definitive legal determination of COPPA applicability. This prompt detects signals; it does not interpret the "child-directed" standard. Guardrail: The output must always be an escalation recommendation, never a final "compliant" or "not compliant" label. Human review is mandatory before any compliance action.

04

Bad Fit: Real-Time Behavioral Biometrics

Avoid when: you need to infer age from keystroke dynamics, mouse movements, or voice patterns. This prompt works on semantic text content, not behavioral signals. Guardrail: Keep this prompt scoped to text analysis. Do not feed it behavioral metadata or sensor data, as it will hallucinate correlations.

05

Required Inputs: Context Window

Risk: A single message like "my birthday is next week" is ambiguous. Guardrail: Always provide the prompt with the full conversation turn or profile section, not just an isolated sentence. Include the [MESSAGE_HISTORY] or [PROFILE_BLOCK] variable to reduce false positives from out-of-context fragments.

06

Operational Risk: Alert Fatigue

Risk: A high false-positive rate will cause the human review team to ignore flags. Guardrail: Implement a confidence threshold. Only route "HIGH" confidence detections for immediate review. "MEDIUM" confidence can be batched. Continuously evaluate the false-positive rate against a labeled golden dataset of known child and adult text.

PROMPT PLAYBOOK

Copy-Ready Prompt Template

Paste this prompt into your system instructions to detect indicators of under-13 user data, child-directed content, and age-gating bypass attempts.

This prompt template is designed to be deployed as a system-level instruction for a classifier model. It analyzes a given input for signals that may trigger obligations under the Children's Online Privacy Protection Act (COPPA). The prompt instructs the model to look for explicit age statements, contextual clues about the user or intended audience, and attempts to circumvent age verification. The output is a structured JSON object that can be used by an orchestration layer to route the interaction for human review, block processing, or apply a restricted data handling policy.

markdown
You are a COPPA risk detection classifier. Analyze the [INPUT_TEXT] provided below for indicators that the user is under 13 years old, that the content is directed at children under 13, or that there is an attempt to bypass age-gating mechanisms. Do not infer age from ambiguous statements. Base your analysis strictly on the provided text.

# Analysis Criteria
1.  **Explicit Age Disclosure:** Does the text state an age under 13, a birthdate indicating an age under 13, or a grade level typically associated with children under 13 (K-6)?
2.  **Child-Directed Content:** Does the text contain references to child-directed activities, media characters, schools, or language patterns that strongly suggest the subject matter is targeted at a pre-teen audience?
3.  **Age-Gating Bypass:** Does the text contain lies about age (e.g., "I am 18 but I'm in 5th grade"), requests for help bypassing an age wall, or inconsistent age statements?

# Constraints
- [CONSTRAINTS]: Do not flag content as a risk based solely on the use of childish language by an adult, discussions about parenting, or historical recollections. If no indicators are present, the risk level must be `none`.
- [RISK_LEVEL]: The final risk level must be one of `none`, `low`, `medium`, or `high`. A `high` risk level requires an explicit age disclosure under 13 or a clear admission of an age-gating bypass attempt.

# Output Format
Return ONLY a valid JSON object with the following structure. Do not include any text outside the JSON object.
[OUTPUT_SCHEMA]:
{
  "risk_level": "none",
  "indicators": [
    {
      "type": "explicit_age_disclosure | child_directed_content | age_gating_bypass",
      "evidence": "The exact text string that triggered the indicator.",
      "confidence": 0.0
    }
  ],
  "requires_human_review": false,
  "recommended_action": "allow | flag_for_review | block_and_escalate"
}

# Input Text
[INPUT_TEXT]

To adapt this template for production, replace the placeholders with your specific platform logic. The [CONSTRAINTS] placeholder should be updated with your organization's specific policy nuances, such as handling educational content or known adult users. The [OUTPUT_SCHEMA] can be extended to include fields like a unique trace_id for logging. Crucially, the [INPUT_TEXT] must be pre-processed to remove any previously collected PII before being passed to this prompt to avoid creating new compliance risks. After deployment, monitor the requires_human_review flag closely; a high rate of flag_for_review decisions may indicate that the [CONSTRAINTS] are too broad and need refinement to reduce operational load on your review team.

IMPLEMENTATION TABLE

Prompt Variables

Inputs the prompt needs to work reliably. Validate these before each invocation to prevent misclassification of children's data and ensure regulatory compliance.

PlaceholderPurposeExampleValidation Notes

[USER_INPUT]

The raw text, message, or content to be analyzed for COPPA-related risk indicators

User profile bio: "I'm in 5th grade and love Minecraft!"

Required. Must be non-empty string. Check for null or whitespace-only inputs before invocation. Truncate to 8192 tokens if longer to avoid context overflow.

[CONTEXT_TYPE]

Specifies the source channel or content type to calibrate detection sensitivity

user_profile, chat_message, form_submission, content_upload, voice_transcript

Required. Must match one of the predefined enum values. Invalid types should cause pre-flight rejection with error message listing valid options.

[AGE_INDICATOR_THRESHOLD]

Confidence floor for flagging explicit age statements as under-13 indicators

0.85

Required. Float between 0.0 and 1.0. Values below 0.7 produce excessive false positives; above 0.95 risks missing obfuscated age references. Default 0.85 if not specified.

[ESCALATION_LEVEL]

Determines the routing severity and required review workflow when risk is detected

immediate_lock, human_review_queue, log_and_continue, block_processing

Required. Must match predefined escalation enum. 'immediate_lock' and 'block_processing' require secondary approval before automated enforcement. 'log_and_continue' only valid for low-confidence detections.

[JURISDICTION]

Specifies the applicable regulatory framework to check against

US_COPPA, UK_AADC, GDPR_KIDS, AU_Privacy_Act

Required. Must match supported jurisdiction enum. Mismatched jurisdiction can cause incorrect age threshold application (e.g., under-13 vs under-16). Validate against allowed list before prompt assembly.

[PARENTAL_CONSENT_STATUS]

Current known consent state for the user account, if available from identity system

not_verified, pending, verified, expired, not_applicable

Optional. If null, prompt should assume no consent exists. If 'verified' and recent, should reduce false escalation. Validate against account system of record; do not trust user-provided claims.

[PREVIOUS_RISK_SCORE]

Prior risk classification result for this user or session, enabling escalation trending

{"score": 0.72, "timestamp": "2025-01-15T14:22:00Z", "flags": ["age_statement"]}

Optional. If provided, must parse as valid JSON with score, timestamp, and flags fields. Stale scores (>30 days) should be discarded. Used to detect repeated bypass attempts across sessions.

PROMPT PLAYBOOK

Implementation Harness Notes

How to wire the COPPA risk detection prompt into a production application with validation, retry logic, logging, and mandatory human review gates.

This prompt is not a standalone safety net; it is a classification component inside a larger compliance pipeline. The harness must treat every positive detection as a blocking event that halts downstream processing, logs an immutable audit record, and routes the interaction to a human review queue. Because false negatives carry regulatory risk under the Children's Online Privacy Protection Act (COPPA), the harness should default to escalation when the model returns low-confidence or ambiguous scores. The prompt output is advisory—the application enforces the decision.

Wire the prompt as a synchronous pre-processing step before any user-generated content enters storage, personalization, or analytics systems. On each request, construct the prompt with the user's raw input in the [INPUT] field and any available session metadata (account age, declared age gate status, content topic) in the [CONTEXT] field. Parse the JSON response and validate the schema strictly: risk_level must be one of none, low, medium, high, or critical; indicators must be an array of strings matching known indicator codes; confidence must be a float between 0.0 and 1.0. If validation fails, retry once with the same input and a stronger constraint instruction appended to the prompt. If the retry also fails validation, escalate to the on-call compliance engineer and block the interaction. For any risk_level of medium or above, or any confidence below 0.85, route the full interaction context—including the raw prompt, model response, and session metadata—to a human review queue with a strict 24-hour SLA. Log every classification result, validation pass/fail, retry attempt, and human review outcome to an append-only audit store with tamper-evident hashing. This log becomes your primary evidence in any regulatory inquiry.

Model choice matters here. Use a model with strong instruction-following and low refusal rates on safety-classification tasks. Avoid models that over-refuse on child-safety topics, as they will produce empty or evasive outputs that fail schema validation. Set temperature=0 and top_p=1 for deterministic outputs. Implement a circuit breaker that blocks all processing if the classification service returns errors for more than 5% of requests in a rolling 5-minute window—this prevents silent failures from creating a compliance gap. Do not use this prompt's output to automatically reject or delete user accounts; the human reviewer must confirm the detection before any account action. The prompt detects risk; the harness enforces process.

IMPLEMENTATION TABLE

Expected Output Contract

Downstream routing, logging, and human-review systems depend on this exact JSON structure. Validate every field before acting on the classification.

Field or ElementType or FormatRequiredValidation Rule

risk_level

enum: none | low | medium | high | critical

Must be exactly one of the five enum values. Reject any other string.

risk_score

integer 0-100

Must be an integer within inclusive range 0-100. Map to risk_level: 0=none, 1-25=low, 26-60=medium, 61-85=high, 86-100=critical.

indicators

array of strings

Must be a non-empty array if risk_score > 0. Each string must match a known indicator from the taxonomy: age_mention, child_directed_content, age_gate_bypass, data_collection_minor, parental_consent_missing, child_profile_image, school_reference, under_13_identifier.

indicator_evidence

array of objects

Each object must contain 'indicator' (string, matching an indicators entry), 'quote' (string, exact text from [INPUT]), and 'confidence' (float 0.0-1.0). Array must not be empty if indicators is non-empty.

requires_human_review

boolean

Must be true if risk_level is 'high' or 'critical', or if any indicator_evidence entry has confidence < 0.85. Otherwise false.

escalation_reason

string or null

Required and non-null if requires_human_review is true. Must cite specific indicators or confidence gaps. Null allowed only when requires_human_review is false.

recommended_action

enum: proceed | flag_for_review | quarantine | escalate_legal

Must be 'proceed' for risk_level none; 'flag_for_review' for low; 'quarantine' for medium or high; 'escalate_legal' for critical.

processing_restrictions

array of strings

Must include 'no_persistence' if risk_level is medium or above. Must include 'no_training_data' if risk_level is high or critical. Must include 'parental_consent_required' if indicator 'parental_consent_missing' is present.

PRACTICAL GUARDRAILS

Common Failure Modes

COPPA detection prompts fail in predictable ways that create regulatory exposure. Test these scenarios before deployment to prevent under-13 data from reaching downstream processing.

01

Age Obfuscation Through Negation

What to watch: Users write 'I am not 12' or 'I am definitely over 13' to bypass detection. Simple keyword matching misses these patterns, and models can be confused by the negation structure. Guardrail: Include few-shot examples with negated age statements labeled as HIGH RISK. Validate with test cases like 'I'm totally not a kid, I'm 20' and 'My age is definitely above 13.'

02

False Positives on Retrospective Content

What to watch: Adults discussing childhood memories ('When I was 8, I loved this game') or parents describing their children ('My 10-year-old uses this app') trigger false COPPA flags. Over-blocking legitimate adult users creates friction and support load. Guardrail: Add a temporal context check in the prompt: distinguish between current age statements and retrospective or third-party descriptions. Route ambiguous cases to human review rather than auto-blocking.

03

Indirect Age Signals Missed

What to watch: Users reveal age through grade level ('I'm in 5th grade'), school references ('my middle school teacher'), or developmental milestones ('just learned to read chapter books'). Models relying only on explicit age numbers miss these signals entirely. Guardrail: Expand the prompt's detection taxonomy to include grade levels, school types, developmental markers, and content consumption patterns typical of under-13 users. Test with a dedicated indirect-signal eval set.

04

Child-Directed Content Misclassification

What to watch: Content that appeals to children (cartoon characters, simple vocabulary, game references) but comes from adult users (animators, game developers, parents) gets flagged incorrectly. The model conflates child-directed content with child-originated content. Guardrail: Separate the prompt's detection dimensions: child-originated data vs. child-directed content. Apply different routing rules for each. Child-directed content from verified adult accounts should not trigger the same escalation as suspected under-13 user data.

05

Multilingual Age Claims Bypass Detection

What to watch: Users switch languages to bypass English-only detection ('Tengo 11 años' or 'J'ai 9 ans'). Monolingual prompts miss non-English age disclosures, creating a dangerous detection gap in global platforms. Guardrail: Include multilingual few-shot examples covering your platform's top languages. Add a pre-processing language detection step that routes non-English inputs to translated analysis before COPPA classification. Test with age claims in Spanish, French, Arabic, and Mandarin.

06

Confidence Threshold Calibration Drift

What to watch: The model's confidence scores shift over time or across model versions. A threshold set at 0.7 today might produce different false-positive rates after a model update. Silent drift breaks your escalation logic without obvious errors. Guardrail: Implement a held-out calibration set with known-age examples and run it weekly. Monitor precision and recall at your chosen threshold. Trigger an alert if false-negative rate on known under-13 cases exceeds 1% or false-positive rate on known adult cases exceeds 5%.

IMPLEMENTATION TABLE

Evaluation Rubric

How to test output quality before shipping. Run these checks against a golden dataset of at least 200 labeled examples covering all risk levels and indicator types.

CriterionPass StandardFailure SignalTest Method

Risk Level Accuracy

Exact match with ground-truth label for 95% of samples

Misclassification rate >5% on golden set; high-risk samples labeled low-risk

Run against 200 labeled examples; compute precision/recall per risk level

Indicator Type Recall

All present indicator types in [INPUT] are identified with recall ≥0.90

Missing indicator types in output; recall <0.90 on golden set

Compare extracted indicator_type list against labeled indicators; measure recall

False Positive Rate on Clean Content

≤3% of non-child-directed content flagged as risk

3% of clean samples receive risk_level other than none

Test on 100 verified non-child content samples; count false positives

Age-Gating Bypass Detection

≥0.95 recall on age-gating bypass attempts in golden set

Bypass attempts classified as none or low risk

Isolate 50 labeled bypass samples; verify risk_level is high and indicator_type includes age_gating_bypass

Confidence Score Calibration

Mean confidence ≥0.85 for correct classifications; mean ≤0.60 for incorrect

High confidence on wrong labels; low confidence on correct labels

Bin predictions by confidence; compute expected calibration error (ECE)

Escalation Flag Correctness

escalation_required is true for all high-risk samples and false for all none samples

High-risk sample missing escalation flag; none sample incorrectly escalated

Check escalation_required boolean against ground-truth risk_level; measure F1

Output Schema Compliance

100% of outputs parse against [OUTPUT_SCHEMA] without field errors

Missing required fields; wrong types; extra fields not in schema

Validate all outputs with JSON Schema validator; count schema violations

Latency Under Load

95th percentile response time ≤2 seconds for single-input classification

p95 latency exceeds 2 seconds in batch test of 200 samples

Measure end-to-end response time across 200 sequential classifications; compute p95

ADAPTATION OPTIONS

Adapt This Prompt

How to adapt

Use the base prompt with a frontier model (GPT-4o, Claude 3.5 Sonnet) and lighter validation. Focus on signal detection over strict schema enforcement. Accept raw JSON output without field-level validation.

code
Analyze the following [CONTENT] for indicators of children's data under COPPA.
Return a JSON object with:
- "likely_under_13": boolean
- "indicators": string[]
- "confidence": "low" | "medium" | "high"

Watch for

  • Missing schema checks producing malformed JSON in edge cases
  • Overly broad instructions catching legitimate adult content with child mentions
  • No confidence calibration—"high" confidence on weak signals
  • No handling of mixed-age contexts (parent mentioning child)
Prasad Kumkar

About the author

Prasad Kumkar

CEO & MD, Inference Systems

Prasad Kumkar is the CEO & MD of Inference Systems and writes about AI systems architecture, LLM infrastructure, model serving, evaluation, and production deployment. Over 5+ years, he has worked across computer vision models, L5 autonomous vehicle systems, and LLM research, with a focus on taking complex AI ideas into real-world engineering systems.

His work and writing cover AI systems, large language models, AI agents, multimodal systems, autonomous systems, inference optimization, RAG, evaluation, and production AI engineering.