Multi-Language PII Detection Prompt Template

This prompt is designed for security engineers and platform teams who need a post-generation safety net that catches personally identifiable information (PII) in model outputs before those outputs enter logs, databases, or user-facing surfaces. It is built for global platforms where model outputs may contain English, CJK, Arabic, Cyrillic, and other Unicode scripts. The prompt instructs the model to act as a multilingual PII scanner, returning a structured JSON report of findings with character-level spans, PII categories, and confidence scores. Use this when regex-based scanners fail on non-Latin scripts, when you need locale-aware name format recognition, or when you need a single prompt that handles mixed-language text without separate per-language pipelines.

Deploy this prompt in a post-processing layer that sits between your primary model's output and any downstream consumer—whether that's a logging pipeline, a database insert operation, or a user-facing UI. The prompt accepts free-text input and returns a machine-readable audit report, making it suitable for automated gating decisions. For example, if the confidence score for a detected email address exceeds 0.85, your application can automatically redact the span before storage. If a borderline case falls between 0.5 and 0.85, route it to a human review queue. This prompt is not a replacement for deterministic input sanitization or transport-layer encryption; it is a defense-in-depth measure for catching PII that the model inadvertently generated or regurgitated from its training data.

Do not use this prompt as your sole PII defense for regulated data subject to HIPAA, PCI DSS, or GDPR without additional controls. The model's detection recall will vary across languages and PII categories, and false negatives are possible—especially for uncommon name formats, oblique references to protected attributes, or PII embedded in images or structured tables. Always pair this prompt with a human review step for high-risk outputs, maintain an audit trail of redaction decisions, and run periodic evaluations against a golden dataset of known PII examples in your target languages. If your use case requires real-time streaming redaction with sub-50ms latency, a model-based scanner may be too slow; consider a hybrid approach where regex handles high-confidence patterns and this prompt handles ambiguous or multilingual cases.

This template is designed for global platforms that process non-English model outputs. It detects personally identifiable information (PII) across multiple languages and scripts, including Unicode, CJK, Arabic, and Cyrillic, with awareness of locale-specific name formats and identifier patterns. Paste this prompt into your system or user message, replacing square-bracket placeholders with your specific inputs. The prompt instructs the model to scan the provided text, identify PII instances, and return a structured JSON report suitable for downstream redaction or logging pipelines.

textCopy
You are a multilingual PII detection system. Your task is to scan the provided text and identify all instances of personally identifiable information (PII) across any language or script present in the input.

## INPUT
[INPUT_TEXT]

## DETECTION CATEGORIES
Scan for the following PII categories, adapting patterns to the locales and scripts detected in the text:
- Person names (full names, given names, surnames, including CJK, Arabic, Cyrillic, and other script formats)
- Email addresses
- Phone numbers (international and local formats)
- Physical addresses and postal codes
- Government identifiers (SSN, national ID, passport numbers, etc., per locale)
- Financial account numbers (credit cards, IBANs, bank accounts)
- IP addresses
- Dates of birth
- Online identifiers (usernames, handles, profile URLs)

## CONSTRAINTS
- Do NOT flag placeholder or test data (e.g., "John Doe", "test@example.com", "123-45-6789" used in documentation) as PII.
- Do NOT flag fictional character names or public figures unless combined with other PII.
- For each detection, assess whether the match is a true PII instance or a benign string that matches a PII pattern.
- If the text contains multiple languages, apply locale-appropriate detection rules for each segment.

## OUTPUT_SCHEMA
Return a valid JSON object with the following structure:
{
  "contains_pii": boolean,
  "detections": [
    {
      "category": string,
      "value": string,
      "language": string | null,
      "confidence": "high" | "medium" | "low",
      "needs_review": boolean,
      "rationale": string
    }
  ],
  "redacted_text": string,
  "uncertain_cases": [
    {
      "value": string,
      "category": string,
      "reason_for_uncertainty": string
    }
  ]
}

## INSTRUCTIONS
1. Scan the entire input text thoroughly.
2. For each detection, populate the category, value, language (if identifiable), confidence level, and a brief rationale.
3. Set `needs_review` to true for any detection with medium or low confidence, or where contextual disambiguation is required.
4. Generate `redacted_text` by replacing each detected PII value with a category-appropriate placeholder (e.g., [EMAIL], [PHONE], [NAME]).
5. List any borderline cases in `uncertain_cases` with the reason for uncertainty.
6. Return ONLY the JSON object. No additional commentary.

To adapt this template, replace [INPUT_TEXT] with the model output you need to scan. You can extend the DETECTION CATEGORIES list with additional PII types relevant to your domain—for example, adding medical record numbers for healthcare or passport numbers for travel platforms. If your application requires a specific redaction style (masking, hashing, or deletion), modify the redacted_text generation instruction accordingly. For high-risk domains such as healthcare or finance, always route uncertain_cases and needs_review: true detections to a human review queue before the output enters any persistent store or user-facing surface.

Before deploying this prompt to production, validate its performance against a golden dataset containing known PII instances in your target languages. Common failure modes include false negatives on non-Latin script names, misclassification of business addresses as personal PII, and over-redaction of benign strings that match PII patterns (such as version numbers that resemble dates). Run the prompt through your evaluation harness with recall and precision metrics, and log every detection decision for auditability. If your latency budget is tight, consider pre-filtering with regex-based pattern matching for high-confidence categories like emails and phone numbers before invoking the LLM for contextual disambiguation.

This prompt is designed to operate as a post-generation safety net, sitting between the model's raw output and any downstream system—logs, databases, APIs, or user-facing surfaces. The implementation harness must treat the prompt as a stateless function: accept a text payload and a locale hint, return a structured detection result, and never allow unvalidated output to bypass the guard. Because PII detection is a high-risk workflow with regulatory implications, the harness must include mandatory validation of the model's JSON response, a retry loop for malformed outputs, and an escalation path for low-confidence detections that require human review.

Wire the prompt into your application as an async post-processing step. After the primary model generates text, pass the raw output to this detection prompt along with a [LOCALE] parameter derived from the user's language preference or the detected language of the content. Use a structured output API or a JSON mode flag to enforce the expected schema. Validate the response immediately: check that detected_pii is an array, each item has the required fields (type, value, start_index, end_index, confidence), and confidence scores are floats between 0.0 and 1.0. If validation fails, retry up to two times with an explicit error message appended to the prompt context. Log every detection event—including the redacted output, the detection summary, and the model version—to an append-only audit store. For detections with confidence below 0.85, route the output to a human review queue before allowing it to proceed. Never log the unredacted original text to observability systems; only the sanitized version and the detection metadata should enter logs.

Choose a fast, cost-efficient model for this detection step—the prompt is a classification and extraction task that does not require a large frontier model. A smaller model with strong JSON-following behavior and multilingual tokenization (such as Claude 3.5 Haiku, GPT-4o-mini, or a fine-tuned open-weight model) is appropriate. If your application processes streaming output, buffer chunks into sentence-level segments before calling the detector to balance latency against detection accuracy. Avoid running this prompt on every token of a long stream; instead, flush the buffer at natural boundaries like newlines or paragraph breaks. The next step after implementing this harness is to build a regression test suite with known PII examples across all supported languages and scripts, including CJK names, Arabic numerals, Cyrillic addresses, and Unicode homoglyph attacks, to ensure the detection pipeline does not degrade as you update models or prompt versions.