AI Web Scraping: LLM-extractie, Prompt-naar-JSON & Kosten

LLM-extractie verandert elke pagina in schone JSON vanuit een eenvoudig Engels prompt — geen selectors om te onderhouden. Maar het model kan de pagina niet ophalen en ruwe HTML verbruikt snel tokens. Hier is hoe je het goed doet.

AI web scraping betekent een taalmodel op een pagina richten en in eenvoudig Engels vragen om de velden die je terug wilt als JSON — geen CSS-selectors om te schrijven, geen parser om te onderhouden wanneer de lay-out verandert. Het is echt transformerend voor rommelige, gevarieerde of eenmalige extracties. Het wordt ook vaak verkeerd begrepen, waardoor mensen betalen om een paar honderd pagina's te scrapen en hallucinatiegegevens terugkrijgen. Twee feiten lossen het meeste van die verwarring op: een taalmodel kan geen webpagina ophalen — het redeneert alleen over tekst die je het geeft — en het voeden met ruwe HTML is de snelste manier om je tokenbudget te verbranden. Deze gids behandelt het extractiepatroon dat werkt, wanneer het selectors overtreft, en hoe je zowel kosten als hallucinatie onder controle houdt.

Het ding dat niemand zegt: het model kan niet ophalen

Het moeilijke deel van AI-scraping is niet de AI. Een chatbot kan niet betrouwbaar een live pagina laden — het heeft een speciale engine nodig om eerst de HTML op te halen, daarna redeneert het over welke tekst je ook geeft. Dus een LLM-extractiepijplijn is eigenlijk een scrapingpijplijn met een slimme parser aan het einde, en de scrapinghelft is waar dingen misgaan: botbeheer, JavaScript-rendering, IP-blokkades. Los het ophalen op met proxies en een renderlaag, en de extractie wordt het gemakkelijke deel. De schone manier om pagina's te krijgen is een scraper API die rotatie en rendering afhandelt en markdown retourneert, wat — zoals de volgende sectie laat zien — ook de goedkoopste mogelijke invoer voor een model is:

import requests

def fetch_markdown(url, api_key):
    r = requests.get(
        "https://api.quantumproxies.io/scrape",
        params={"url": url, "render": "auto", "output": "markdown"},
        headers={"Authorization": f"Bearer {api_key}"},
        timeout=(5, 40),
    )
    r.raise_for_status()
    return r.json()["markdown"]  # nav/ads stripped, ready for the model

Waarom markdown, niet HTML, de echte kostenhefboom is

De grootste drijfveer van AI-scrapingkosten is hoeveel tokens je door het model duwt, en ruwe HTML is meestal tokens die je niet wilt: inline stijlen, script-tags, trackingattributen, navigatie, voetnoten. Converteer de pagina naar schone markdown — of extraheer alleen de hoofdinhoud — vóór extractie en je verkleint routinematig de invoergrootte met een orde van grootte, wat de kosten met dezelfde factor verlaagt en, als bonus, hallucinatie vermindert omdat het model de inhoud ziet in plaats van de chrome. Dit is waarom markdown-first de standaard is voor het voeden van modellen, hetzelfde principe achter het voeden van LLMs met verse webgegevens. Als je maar één ding uit dit artikel haalt: stuur nooit een model de ruwe pagina bron.

Prompt-naar-JSON met een schema

Zodra je schone tekst hebt, is extractie een enkele oproep: beschrijf de velden die je wilt, geef een schema door zodat de uitvoer gestructureerd is, en instrueer het model om null te retourneren in plaats van te verzinnen wanneer een veld ontbreekt. Een extractie API comprimeert ophalen, schoonmaken en extraheren in één verzoek zodat je de leidingen volledig overslaat:

curl -X POST "https://api.quantumproxies.io/extract" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://example.com/product/xyz",
    "schema": {
      "title":  "string",
      "price":  "number",
      "in_stock": "boolean",
      "rating": "number|null"
    },
    "prompt": "Extract the product. Use null for anything not present."
  }'

Het schema heeft een dubbele functie: het dwingt een voorspelbare vorm af voor downstream code, en het beperkt het model, wat de eerste verdedigingslinie is tegen gehallucineerde velden. Valideer de respons tegen hetzelfde schema en wijs alles af dat niet past — een verzonnen prijs is erger dan een ontbrekende.

def validate(record, schema):
    for field, kind in schema.items():
        v = record.get(field)
        if v is None and "null" not in kind:
            raise ValueError(f"missing required field: {field}")
    return record  # only trust records that satisfy the schema

Wanneer LLM-extractie CSS-selectors overtreft — en wanneer niet

AI-extractie is geen universele upgrade; het is een ander hulpmiddel met een andere kostencurve. Grijp ernaar wanneer het werk gevarieerd of onstabiel is — het scrapen van duizend sites met duizend lay-outs, een site die voortdurend opnieuw wordt ontworpen, ongestructureerde inhoud zoals recensies of lijsten waar geen schone selector bestaat, of een eenmalige klus waar het schrijven van selectors de tijd niet waard is. Blijf bij CSS of XPath selectors wanneer je één stabiele site op hoog volume bewerkt: selectors zijn deterministisch, effectief gratis per pagina, en hallucineren nooit. Het volwassen patroon is hybride — selectors voor je kern doelwitten met hoog volume, LLM-extractie voor de lange staart en de sites die blijven veranderen.

Kostenbeheersing verandert dit van een experiment in productie. Naast markdown-first, cache agressief zodat je nooit een ongewijzigde pagina opnieuw extraheert, stem modelgrootte af op taakmoeilijkheid — een klein model verwerkt eenvoudige veldextractie prima — en batch waar de API het toestaat. Rendering is een eigen kostenpost; render alleen pagina's die echt JavaScript nodig hebben, een beslissing die we kwantificeren in render alleen wanneer je moet. Krijg een blanco pagina in plaats van inhoud en de oplossing is meestal rendering, behandeld in lege pagina, ontbrekende gegevens.

Een woord over de gratis en open-source route, aangezien dat is waar de meeste mensen eerst naar zoeken. Open-source extractiebibliotheken zijn uitstekend om het patroon te leren en voor kleine klussen, maar ze geven je de twee moeilijke problemen terug waarmee dit artikel begon: je moet nog steeds pagina's ophalen voorbij botbeheer, en je betaalt nog steeds voor welk model de extractie doet. 'Gratis' betekent meestal gratis code plus je eigen proxy- en tokenrekeningen. Dat is een prima ruil voor een hobbyproject of een proof of concept; bij productieniveau is het onderhoud van de ophaallaag precies wat teams uiteindelijk uitbesteden, een bouw-versus-kopen beslissing die we uiteenzetten in DIY scraper stack vs een scraper API.

Veelgestelde vragen

Kan ChatGPT een website scrapen?

Niet op zichzelf. Een taalmodel kan niet betrouwbaar een live pagina ophalen en renderen — het redeneert over tekst die je geeft. Om AI voor scraping te gebruiken, koppel je een speciale scraping-engine, die de pagina ophaalt en schoonmaakt, met het model, dat gestructureerde gegevens uit het resultaat extraheert. De scraping-engine behandelt proxies, rendering en blokkades; het model zorgt voor het omzetten van inhoud in JSON.

Hoe verlaag ik de kosten van AI web scraping?

Converteer pagina's naar markdown of extraheer de hoofdinhoud voordat je iets naar een model stuurt — ruwe HTML kan tien keer de tokens zijn voor dezelfde informatie. Cache dan ongewijzigde pagina's, gebruik een kleiner model voor eenvoudige veldextractie, render JavaScript alleen wanneer een pagina het vereist, en batch verzoeken. Tokenvolume is de dominante kostenfactor, dus het verkleinen van de invoergrootte is de optimalisatie met de hoogste hefboomwerking.

Hallucineert AI web scraping verkeerde gegevens?

Het kan, vooral wanneer het wordt gevoed met rommelige ruwe HTML of wordt gevraagd om velden die niet op de pagina staan. Bescherm ertegen door de invoer schoon te maken, een expliciet schema door te geven, het model te instrueren om null te retourneren wanneer een waarde ontbreekt, en elke respons tegen dat schema te valideren voordat je het vertrouwt. Een ontbrekend veld kun je opnieuw proberen; een zelfverzekerd verzonnen veld corruptieert stilletjes je dataset.

Is LLM-extractie beter dan CSS-selectors?

Het hangt af van de klus. LLM-extractie wint wanneer lay-outs variëren of vaak veranderen en wanneer het schrijven van selectors de moeite niet waard is, omdat het geen selectors nodig heeft en herontwerpen overleeft. CSS-selectors winnen op een enkele stabiele site met hoog volume: ze zijn deterministisch en veel goedkoper per pagina. De meeste productie-pijplijnen gebruiken selectors voor kern doelwitten en LLM-extractie voor de lange staart.

AI web scraping is krachtig zodra je stopt met het behandelen van het model als een scraper. Haal schoon op met proxies, voed markdown niet HTML, beperk de uitvoer met een schema, en reserveer LLM-extractie voor de klussen waar zijn flexibiliteit zijn tokenkosten waard is. Dat is het verschil tussen een vlotte demo en een pijplijn die je elke dag kunt draaien.

Zet elke pagina om in JSON met de Extract API