Stamp Detection and Classification Prompt

This prompt is designed for document intake engineers and automation architects who need to detect, classify, and extract content from official marks—such as approval stamps, date stamps, notary seals, and corporate chops—in high-volume document pipelines. The primary job is to identify whether a document contains a stamp, determine its type, extract any text it carries, and report its location with a confidence score. This is a critical step in workflows like loan processing, government form intake, and contract execution verification, where the presence or absence of a stamp directly determines downstream routing, compliance checks, or human review requirements.

Use this prompt when you have a pre-processed page image or a high-resolution scan and you need structured output that can be consumed by an application. The prompt expects a clear image input and an output schema that defines the fields you need—typically stamp_type, bounding_box, extracted_text, and confidence. It is built to handle overlapping stamps, faint impressions, and color variations, but it is not a substitute for a dedicated OCR engine. You should only use this prompt after the document has been rasterized and, if necessary, enhanced for contrast. The prompt works best when paired with a validation layer that checks for common failure modes, such as confusing a dark logo with a stamp or misclassifying a printed border as a notary seal.

Do not use this prompt for general object detection, signature verification, or handwritten annotation classification—those are separate, specialized tasks. It is also not suitable for real-time video streams or low-resolution images below 150 DPI, where stamp details are illegible. If your workflow involves legally binding decisions based on stamp presence, you must route low-confidence detections (e.g., confidence < 0.85) to a human review queue and log the model's output alongside the source image for auditability. The next step after reading this section is to prepare your image preprocessing pipeline and define the exact JSON schema your downstream system expects.

This template provides a complete instruction set for stamp detection and classification. It is designed to be dropped into a system prompt or a single-turn user message where the document image is provided alongside the instruction. The prompt enforces structured JSON output, requires bounding box coordinates, and explicitly separates stamp content from surrounding document text to prevent extraction bleed. Use this template as your starting point, then tune the confidence thresholds, stamp type taxonomy, and coordinate normalization to match your document pipeline's requirements.

textCopy
You are a document analysis system specialized in detecting and classifying stamps, seals, and official marks on document pages.

## INPUT
You will receive a single document page as an image. The page may contain zero or more stamps.

## TASK
Detect all stamps on the page. For each detected stamp, provide:
- Classification of the stamp type
- Bounding box coordinates
- All text content extracted from within the stamp region
- A confidence score

## STAMP TYPE TAXONOMY
Classify each stamp into exactly one of the following types:
- [STAMP_TYPE_TAXONOMY]

## OUTPUT SCHEMA
Return a JSON object with this exact structure:
{
  "page_number": [PAGE_NUMBER],
  "stamps_detected": [STAMP_COUNT],
  "stamps": [
    {
      "stamp_id": "string",
      "stamp_type": "string from taxonomy",
      "confidence": 0.0-1.0,
      "bounding_box": {
        "x": number,
        "y": number,
        "width": number,
        "height": number,
        "unit": "pixels"
      },
      "text_content": "string extracted from stamp",
      "text_confidence": 0.0-1.0,
      "visual_characteristics": ["list of observed features"],
      "overlaps_other_stamp": boolean,
      "illegible": boolean
    }
  ],
  "processing_notes": ["any warnings about image quality, ambiguity, or edge cases"]
}

## CONSTRAINTS
[CONSTRAINTS]

## EXAMPLES
[EXAMPLES]

## IMPORTANT
- Distinguish stamps from watermarks, logos, printed borders, and pre-printed form elements.
- If a stamp is faint, partially obscured, or overlapping another stamp, note this in visual_characteristics and reduce confidence accordingly.
- Extract text only from within the stamp boundary. Do not include surrounding document text.
- If stamp text is partially illegible, set illegible to true and include whatever characters you can read in text_content.
- If no stamps are detected, return stamps_detected as 0 and an empty stamps array.
- For color stamps, note the ink color in visual_characteristics.
- Do not hallucinate stamps. If you are uncertain whether a mark is a stamp, set confidence below 0.5 and explain in processing_notes.

To adapt this template, replace the square-bracket placeholders with your specific requirements. [STAMP_TYPE_TAXONOMY] should contain your domain's stamp categories—common values include approval_stamp, date_stamp, notary_seal, received_stamp, confidential_stamp, certified_copy, void_stamp, and custom. [CONSTRAINTS] is where you add domain-specific rules such as minimum confidence thresholds for auto-acceptance, coordinate system requirements (normalized vs. pixel), or multi-language text extraction preferences. [EXAMPLES] should contain one-shot or few-shot examples showing correct outputs for stamps your system commonly encounters, including edge cases like overlapping stamps or faint impressions. If you are integrating this into a production pipeline, add a post-processing validation step that checks bounding box coordinates are within page dimensions, stamp_id values are unique, and confidence scores are within the 0.0-1.0 range before the output reaches downstream systems.

The stamp detection prompt is designed to operate as a focused extraction step within a larger document processing pipeline, not as a standalone application. It expects pre-processed page images or high-quality OCR text with spatial metadata as input. The ideal integration point is after document classification and page splitting, but before downstream field extraction or completeness auditing. This ordering ensures that stamp regions are identified and can be excluded from text extraction zones, preventing stamp text from being misinterpreted as form field content. The prompt should be called once per page for multi-page documents, with results aggregated at the document level.

Wire the prompt into your application using a structured API call with explicit JSON schema enforcement. The model should be configured with response_format set to a strict JSON object matching the expected output schema: an array of stamp objects, each containing stamp_type (enum: official_seal, approval_stamp, date_stamp, notary_seal, received_stamp, other), bounding_box (normalized coordinates), extracted_text, confidence (0.0-1.0), and overlap_flag (boolean). Implement a validation layer that checks for schema compliance, coordinate range validity, and confidence threshold enforcement. Stamps with confidence below 0.7 should be routed to a human review queue with the cropped image region attached. Add a retry loop with a maximum of two attempts: if the model returns malformed JSON or missing required fields, re-send the same image with an error message appended to the prompt context specifying the validation failure. Log every attempt, validation result, and final disposition for auditability.

For high-volume production use, batch pages and process them concurrently with rate limiting aligned to your model provider's tier. Cache results keyed by page hash to avoid re-processing identical pages during retries or re-ingestion. The most common failure mode in production is stamp-watermark confusion, so implement a post-processing heuristic that checks detected stamp regions against known watermark patterns in your document corpus. If a detected stamp region overlaps with a known watermark location by more than 50%, downgrade the confidence and flag for review rather than silently accepting the misclassification. Do not use this prompt for signature verification or legal validity assessment—those require separate, specialized workflows with human-in-the-loop approval gates.