Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

OCR: Tekstextractie

Les 6 van 12 Bijgewerkt op 30 juli 2026 Beginner
Op deze pagina
  1. Tekst in afbeeldingen lezen
  2. Klassieke OCR versus multimodale OCR
  3. Basisextractie
  4. Gestructureerde documentextractie
  5. Extractie van visitekaartjes
  6. Verwerking van screenshots
  7. Batchverwerking van documenten
  8. Beperkingen van Grok OCR
  9. Belangrijkste punten

Tekst in afbeeldingen lezen

OCR (Optical Character Recognition) is een van de krachtigste use cases voor Grok Vision. In tegenstelling tot traditionele tools die alleen tekens extraheren, begrijpt Grok de context van de tekst in de afbeelding, de lay-out en de betekenis.

Klassieke OCR versus multimodale OCR

Traditionele OCR-tools (Tesseract, Google Vision OCR, AWS Textract) blinken uit in het extraheren van ruwe tekens. Grok voegt een extra dimensie toe: het begrijpt wat de tekst betekent binnen de context van de afbeelding.

Bij het verwerken van een gescande factuur haalt een klassieke OCR-tool bijvoorbeeld alle tekens op. Grok kan daarnaast ook:

  • Velden identificeren (factuurnummer, datum, totaalbedrag)
  • Gegevens structureren in een bruikbaar formaat
  • OCR-fouten corrigeren met behulp van context
  • Tabellen en complexe lay-outs interpreteren

Basisextractie

Voor eenvoudige extractie van zichtbare tekst:

response = client.responses.create(
    model="grok-4.5",
    input=[
        {
            "type": "input_image",
            "image_url": url_document,
            "detail": "high"  # Essential for OCR
        },
        {
            "type": "input_text",
            "text": "Extract all visible text in this image. Preserve the layout as much as possible."
        }
    ],
    store=False
)

De parameter detail: "high" is essentieel voor OCR. In de modus low kan het model fijne tekst missen of bepaalde tekens verkeerd lezen.

Gestructureerde documentextractie

Voor professionele documenten vraagt u om gestructureerde extractie:

def extraire_facture(image_url):
    prompt = """This image is an invoice. Extract the following
information in JSON:
- "invoice_number": the invoice number
- "date": the issue date
- "issuer": name and address of the issuer
- "recipient": name and address of the recipient
- "lines": table with columns [description, quantity, unit_price, total]
- "subtotal": amount excluding tax
- "vat": VAT amount
- "total_incl_tax": amount including tax

If a field is not visible, indicate null."""

    response = client.responses.create(
        model="grok-4.5",
        input=[
            {"type": "input_image", "image_url": image_url, "detail": "high"},
            {"type": "input_text", "text": prompt}
        ],
        store=False
    )
    return response.output_text

Extractie van visitekaartjes

def extraire_carte_visite(image_url):
    prompt = """Extract the information from this business card in JSON:
- "name": full name
- "title": job title/position
- "company": company name
- "email": email address
- "phone": phone number(s)
- "address": postal address
- "website": website URL
- "social_media": links to social media profiles"""

    response = client.responses.create(
        model="grok-4.5",
        input=[
            {"type": "input_image", "image_url": image_url, "detail": "high"},
            {"type": "input_text", "text": prompt}
        ],
        store=False
    )
    return response.output_text

Verwerking van screenshots

Screenshots zijn een uitstekende use case omdat ze vaak tekst bevatten in complexe lay-outs (menu’s, zijbalken, pop-ups):

def analyser_screenshot(image_url):
    prompt = """Analyze this screenshot and identify:
1. The application or website displayed
2. The visible page or section
3. The main interface elements (buttons, menus, forms)
4. Any important text displayed
5. Any error messages or notifications"""

    response = client.responses.create(
        model="grok-4.5",
        input=[
            {"type": "input_image", "image_url": image_url, "detail": "high"},
            {"type": "input_text", "text": prompt}
        ],
        store=False
    )
    return response.output_text

Batchverwerking van documenten

Om een groot volume documenten te verwerken, combineert u Grok OCR met een verwerkingspijplijn:

import json

async def pipeline_ocr(documents):
    resultats = []

    for doc in documents:
        # 1. Validate the image
        if not valider_image(doc["chemin"]):
            resultats.append({"fichier": doc["chemin"], "erreur": "Invalid image"})
            continue

        # 2. Encode to base64
        image_url = encoder_base64(doc["chemin"])

        # 3. Extract with Grok
        response = client.responses.create(
            model="grok-4.5",
            input=[
                {"type": "input_image", "image_url": image_url, "detail": "high"},
                {"type": "input_text", "text": doc["prompt"]}
            ],
            store=False
        )

        # 4. Parse the result
        try:
            data = json.loads(response.output_text)
            resultats.append({"fichier": doc["chemin"], "data": data})
        except json.JSONDecodeError:
            resultats.append({"fichier": doc["chemin"], "texte_brut": response.output_text})

    return resultats

Beperkingen van Grok OCR

  • Handgeschreven tekst: herkenning werkt goed voor leesbaar handschrift, maar kan falen bij cursief of onleesbaar handschrift
  • Niet-Latijnse talen: de nauwkeurigheid varieert afhankelijk van de taal en het gebruikte lettertype
  • Afbeeldingen van lage kwaliteit: scans met lage resolutie of wazige foto’s verslechteren de resultaten
  • Zeer kleine tekst: zelfs in de modus high kan tekst kleiner dan 8 pixels in hoogte verkeerd worden gelezen

Belangrijkste punten

  • Gebruik altijd detail: "high" voor OCR-taken
  • Vraag gestructureerde extractie (JSON) aan om gegevens automatisch te kunnen gebruiken
  • Grok gaat verder dan ruwe OCR: het begrijpt context en lay-out
  • Gebruik store: false voor vertrouwelijke documenten (facturen, visitekaartjes)
  • Valideer en bewerk afbeeldingen vooraf om de extractiekwaliteit te maximaliseren