Olostep Docs - Scrape endpoint

Via de Olostep /v1/scrapes endpoint kun je LLM-vriendelijke Markdown, HTML, tekst, screenshots of gestructureerde JSON in real-time van elke URL extraheren.

Levert schone markdown, gestructureerde data, screenshots of html
Extraheer JSON via Parsers of LLM-extractie
Behandelt dynamische inhoud: js-gerenderde sites, inlogstromen via acties, PDF’s
Bepaal hoe lang resultaten bewaard blijven met de storage parameter

Voor API-details zie de Scrape Endpoint API Reference.

Een URL scrapen

Gebruik de /v1/scrapes endpoint om een enkele URL te scrapen en kies uitvoerformaten.

Installatie

pip install olostep

npm install olostep

# curl is standaard beschikbaar op macOS, Linux en Windows

npm install node-fetch

pip install requests

Gebruik

Je kunt de endpoint gebruiken om een enkele URL te scrapen en uitvoerformaten te kiezen. De verplichte parameters zijn url_to_scrape en formats. Enkele andere veelvoorkomende parameters zijn wait_before_scraping (in milliseconden), remove_css_selectors (standaard, geen, of een array van selectors), en country.

from olostep import Olostep

client = Olostep(api_key="YOUR_REAL_KEY")

result = client.scrapes.create(
    url_to_scrape="https://en.wikipedia.org/wiki/Alexander_the_Great",
    formats=["markdown", "html"],
)

print(result.markdown_content)
print(result.html_content)

import Olostep from 'olostep'

const client = new Olostep({ apiKey: 'YOUR_REAL_KEY' })

const result = await client.scrapes.create({
  url: 'https://en.wikipedia.org/wiki/Alexander_the_Great',
  formats: ['markdown', 'html'],
})

console.log(result.markdown_content)
console.log(result.html_content)

curl -s -X POST "https://api.olostep.com/v1/scrapes" \
  -H "Authorization: Bearer $OLOSTEP_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "url_to_scrape": "https://en.wikipedia.org/wiki/Alexander_the_Great",
    "formats": ["markdown", "html"]
  }'

olostep scrape "https://en.wikipedia.org/wiki/Alexander_the_Great" \
  --formats markdown,html

const endpoint = 'https://api.olostep.com/v1/scrapes'
const payload = {
  url_to_scrape: 'https://en.wikipedia.org/wiki/Alexander_the_Great',
  formats: ['markdown', 'html']
}
const res = await fetch(endpoint, {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer <YOUR_API_KEY>',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify(payload)
})
const data = await res.json()
console.log(data)

import requests
import json

endpoint = "https://api.olostep.com/v1/scrapes"
payload = {
    "url_to_scrape": "https://en.wikipedia.org/wiki/Alexander_the_Great",
    "formats": ["markdown", "html"]
}
headers = {
    "Authorization": "Bearer <YOUR_API_KEY>",
    "Content-Type": "application/json"
}

response = requests.post(endpoint, json=payload, headers=headers)
print(json.dumps(response.json(), indent=2))

Respons

De API retourneert een scrape object als antwoord. De scrape heeft enkele eigenschappen zoals id en result. Het result object heeft de volgende velden (afhankelijk van de formats parameter kunnen sommige null zijn):

html_content: de HTML-inhoud van de pagina. Geef formats: ["html"] door om dit te krijgen.
markdown_content: de MD-inhoud van de pagina. Geef formats: ["markdown"] door om dit te krijgen.
text_content: de tekstinhoud van de pagina. Geef formats: ["text"] door om dit te krijgen.
json_content: de JSON-inhoud van de pagina. Geef formats: ["json"] door om dit te krijgen en geef ook een parser of llm_extract parameter.
screenshot_hosted_url: de gehoste URL van de screenshot.
html_hosted_url: de gehoste URL van de HTML-inhoud
markdown_hosted_url: de gehoste URL van de Markdown-inhoud
json_hosted_url: de gehoste URL van de JSON-inhoud
text_hosted_url: de gehoste URL van de tekstinhoud
links_on_page: de links op de pagina
page_metadata: de metadata van de pagina

{
  "id": "scrape_6h89o8u1kt",
  "object": "scrape",
  "created": 1745673871,
  "metadata": {},
  "retrieve_id": "6h89o8u1kt",
  "url_to_scrape": "https://en.wikipedia.org/wiki/Alexander_the_Great",
  "result": {
    "html_content": "<html...",
    "markdown_content": "## Alexander the Great...",
    "text_content": null,
    "json_content": null,
    "screenshot_hosted_url": null,
    "html_hosted_url": "https://olostep-storage.s3.us-east-1.amazonaws.com/text_6h89o8u1kt.txt",
    "markdown_hosted_url": "https://olostep-storage.s3.us-east-1.amazonaws.com/markDown_6h89o8u1kt.txt",
    "json_hosted_url": null,
    "text_hosted_url": null,
    "links_on_page": [],
    "page_metadata": { "status_code": 200, "title": "" }
  }
}

Caching

Om de snelheid te optimaliseren, biedt Olostep een optionele gedeelde cachinglaag voor HTML-, Markdown-, tekst- en geparseerde JSON-resultaten.

Hoe het werkt

Wanneer een scrape wordt aangevraagd, controleert Olostep of er al een overeenkomende scrape bestaat met dezelfde parameters. Als er een voldoende recente match wordt gevonden, wordt de inhoud direct vanuit Olostep’s opslag geserveerd zonder een nieuwe browser scrape te starten.

Gedeelde Cache: De cache wordt wereldwijd gedeeld. Als een andere aanvraag exact dezelfde URL met exact dezelfde configuratie binnen jouw versheidsvenster heeft gescraped, profiteer je van de snelheidswinst.
Nabewerking is nog steeds live: Operaties zoals llm_extract en links_on_page filters worden on-the-fly uitgevoerd bovenop het gecachte document. Je cachet alleen de kernpagina-ophaling, waardoor je gestructureerde extracties dynamisch blijven.

Versheid en `max_age`

Standaard voert de productie-API altijd een live scrape uit om real-time nauwkeurigheid te garanderen. Je kunt kiezen voor caching met de max_age parameter.

Parameter	Type	Standaard	Beschrijving
`max_age`	`integer`	`0`	Acceptabele inhoudsouderdom in seconden. Als er een gecachte kopie bestaat die nieuwer is dan `max_age` seconden, wordt deze vanuit de cache geserveerd.

Standaard API Gedrag (max_age: 0): Elke API-aanvraag triggert een verse scrape.
Standaard Playground Gedrag: In het dashboard playground is max_age standaard 24 uur (86400 seconden).
Maximale Leeftijd: De cache heeft een harde limiet van 7 dagen (604800 seconden). Elke max_age die boven deze limiet wordt aangevraagd, valt terug naar een maximum van 7 dagen.

Gebruik Voorbeelden

from olostep import Olostep

client = Olostep(api_key="YOUR_REAL_KEY")

# Kies voor caching: Accepteer resultaten tot 1 dag (86400 seconden) oud
result = client.scrapes.create(
    url_to_scrape="https://example.com",
    formats=["markdown"],
    max_age=86400
)

import Olostep from 'olostep'

const client = new Olostep({ apiKey: 'YOUR_REAL_KEY' })

// Kies voor caching: Accepteer resultaten tot 1 dag (86400 seconden) oud
const result = await client.scrapes.create({
  url: 'https://example.com',
  formats: ['markdown'],
  maxAge: 86400,
})

# Kies voor caching: Accepteer resultaten tot 1 uur (3600 seconden) oud
curl -X POST "https://api.olostep.com/v1/scrapes" \
  -H "Authorization: Bearer $OLOSTEP_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "url_to_scrape": "https://example.com",
    "formats": ["markdown"],
    "max_age": 3600
  }'

const endpoint = 'https://api.olostep.com/v1/scrapes'
const payload = {
  url_to_scrape: 'https://example.com',
  formats: ['markdown'],
  max_age: 86400 // Accepteer resultaten tot 1 dag (86400 seconden) oud
}
const res = await fetch(endpoint, {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer <YOUR_API_KEY>',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify(payload)
})
const data = await res.json()
console.log(data)

import requests
import json

endpoint = "https://api.olostep.com/v1/scrapes"
payload = {
    "url_to_scrape": "https://example.com",
    "formats": ["markdown"],
    "max_age": 86400 # Accepteer resultaten tot 1 dag (86400 seconden) oud
}
headers = {
    "Authorization": "Bearer <YOUR_API_KEY>",
    "Content-Type": "application/json"
}

response = requests.post(endpoint, json=payload, headers=headers)
print(json.dumps(response.json(), indent=2))

Wanneer wordt de cache overgeslagen?

De cache wordt automatisch omzeild (waardoor een live scrape wordt geforceerd) wanneer je aanvraag nodig heeft:

Interactieve sessies: Aanvragen die session_id gebruiken of een aangepaste browser context laden.
Screenshots: Elke aanvraag die screenshot in formats opneemt of de screenshotoptie instelt, omzeilt de cache.
Speciale bestandstypen: Binaire bestandsdownloads of ruwe PDF-rendering.
Debugging & Netwerk: Het vastleggen van network_calls of het gebruik van asynchrone parserjobs.

Opslag

Scrape-resultaten worden standaard ongeveer 7 dagen bewaard. Geef een storage object door om een resultaat langer — of voor onbepaalde tijd — te bewaren, zodat je het later opnieuw kunt ophalen. Het resultaat, de gehoste URL’s en GET /v1/scrapes/{scrape_id} blijven beschikbaar voor dat venster. max_age bepaalt of een nieuwe aanvraag een gecachte pagina kan hergebruiken. storage.expires_in bepaalt hoe lang dit scrape-resultaat beschikbaar blijft. Zie Caching voor max_age. storage is beschikbaar op alle plannen voor POST /v1/scrapes.

Parameter	Type	Standaard	Beschrijving
`storage.expires_in`	`string`	ongeveer 7 dagen (wanneer `storage` wordt weggelaten)	Hoe lang het resultaat bewaard moet blijven. Een van `10d`, `30d`, `60d`, `90d`, `180d`, `365d`, of `never` (onbepaald).

Gebruik

from olostep import Olostep

client = Olostep(api_key="YOUR_REAL_KEY")

# Bewaar deze scrape 90 dagen
result = client.scrapes.create(
    url_to_scrape="https://example.com/product/reviews",
    formats=["markdown"],
    storage={"expires_in": "90d"},
)

print(result.id)

import Olostep from 'olostep'

const client = new Olostep({ apiKey: 'YOUR_REAL_KEY' })

// Bewaar deze scrape 90 dagen
const result = await client.scrapes.create({
  url: 'https://example.com/product/reviews',
  formats: ['markdown'],
  storage: { expires_in: '90d' },
})

console.log(result.id)

curl -X POST "https://api.olostep.com/v1/scrapes" \
  -H "Authorization: Bearer $OLOSTEP_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "url_to_scrape": "https://example.com/product/reviews",
    "formats": ["markdown"],
    "storage": { "expires_in": "90d" }
  }'

const endpoint = 'https://api.olostep.com/v1/scrapes'
const payload = {
  url_to_scrape: 'https://example.com/product/reviews',
  formats: ['markdown'],
  storage: { expires_in: '90d' }
}
const res = await fetch(endpoint, {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer <YOUR_API_KEY>',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify(payload)
})
const data = await res.json()
console.log(data)

import requests
import json

endpoint = "https://api.olostep.com/v1/scrapes"
payload = {
    "url_to_scrape": "https://example.com/product/reviews",
    "formats": ["markdown"],
    "storage": {"expires_in": "90d"}
}
headers = {
    "Authorization": "Bearer <YOUR_API_KEY>",
    "Content-Type": "application/json"
}

response = requests.post(endpoint, json=payload, headers=headers)
print(json.dumps(response.json(), indent=2))

Links extraheren

Geef een links_on_page object door in de aanvraag om de links op de pagina te verzamelen. Alle links worden geretourneerd als absolute URL’s.

"links_on_page": {
  "include_links": ["/blog/*"],
  "exclude_links": ["*.pdf"],
  "query_to_order_links_by": "pricing"
}

include_links / exclude_links: glob-patronen die worden gematcht tegen het URL pad van elke link.
query_to_order_links_by: herordent de geretourneerde links op relevantie voor deze tekst.

Glob-patronen matchen padsegmenten. Een enkele * kruist niet /, dus "/blog/*" matcht "/blog/post-1" maar niet de index "/blog" zelf — en het matcht nooit "/blog?tag=x" omdat querystrings geen deel uitmaken van het pad. Om de index ook op te nemen, gebruik "/blog*" of "{/blog,/blog/**}".

Scrape Formaten

Kies een of meer uitvoerformaten via formats:

markdown: LLM-vriendelijke markdown
html: schoongemaakte HTML
text: platte tekst
json: gestructureerde uitvoer (via parser of llm_extract)
raw_pdf: ruwe PDF-bytes geëxtraheerd naar gehoste URL
screenshot: ingesteld via acties om een screenshot te maken en een gehoste URL te retourneren

Uitvoersleutels worden binnen result geretourneerd als *_content velden en een *_hosted_url ook.

Gestructureerde data extraheren

Je kunt gestructureerde JSON op twee manieren extraheren: met behulp van Parsers of LLM-extractie.

Een Parser gebruiken (aanbevolen voor schaal)

Definieer formats: ["json"] en geef een parser id.

from olostep import Olostep

client = Olostep(api_key="YOUR_REAL_KEY")

result = client.scrapes.create(
    url_to_scrape="https://www.google.com/search?q=alexander+the+great&gl=us&hl=en",
    formats=["json"],
    parser="@olostep/google-search",
)

print(result.json_content)

import Olostep from 'olostep'

const client = new Olostep({ apiKey: 'YOUR_REAL_KEY' })

const result = await client.scrapes.create({
  url: 'https://www.google.com/search?q=alexander+the+great&gl=us&hl=en',
  formats: ['json'],
  parser: '@olostep/google-search',
})

console.log(result.json_content)

curl -s -X POST "https://api.olostep.com/v1/scrapes" \
  -H "Authorization: Bearer $OLOSTEP_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "url_to_scrape": "https://www.google.com/search?q=alexander+the+great&gl=us&hl=en",
    "formats": ["json"],
    "parser": {"id": "@olostep/google-search"}
  }'

olostep scrape "https://www.google.com/search?q=alexander+the+great&gl=us&hl=en" \
  --formats json \
  --payload-json '{"parser":{"id":"@olostep/google-search"}}'

const res = await fetch('https://api.olostep.com/v1/scrapes', {
  method: 'POST',
  headers: { 'Authorization': 'Bearer <YOUR_API_KEY>', 'Content-Type': 'application/json' },
  body: JSON.stringify({
    url_to_scrape: 'https://www.google.com/search?q=alexander+the+great&gl=us&hl=en',
    formats: ['json'],
    parser: { id: '@olostep/google-search' }
  })
})
console.log(await res.json())

import requests, json

endpoint = "https://api.olostep.com/v1/scrapes"
payload = {
  "url_to_scrape": "https://www.google.com/search?q=alexander+the+great&gl=us&hl=en",
  "formats": ["json"],
  "parser": { 
    "id": "@olostep/google-search" 
  }
}
headers = {
    "Authorization": "Bearer <YOUR_API_KEY>", 
    "Content-Type": "application/json"
}

res = requests.post(endpoint, json=payload, headers=headers)
print(json.dumps(res.json(), indent=2))

Olostep heeft een aantal vooraf gebouwde parsers voor populaire websites maar je kunt ook je eigen parsers maken via het dashboard of ons team vragen om het voor je te doen. Parsers zijn zelfherstellend en zullen zichzelf bijwerken naar de nieuwste versie van de website.

LLM-extractie gebruiken (schema en/of prompt)

Geef llm_extract met een JSON Schema (schema) en/of een natuurlijke taal instructie (prompt). Je kunt beide parameters doorgeven, maar als beide worden gegeven, heeft schema voorrang. Als je in plaats daarvan alleen een prompt doorgeeft, zal de LLM de gegevens extraheren op basis van de prompt en zelf de datastructuur bepalen.

from olostep import LLMExtract, Olostep

client = Olostep(api_key="YOUR_REAL_KEY")

result = client.scrapes.create(
    url_to_scrape="https://www.berklee.edu/events/stefano-marchese-friends",
    formats=["markdown", "json"],
    llm_extract=LLMExtract(
        schema={
            "type": "object",
            "properties": {
                "event": {
                    "type": "object",
                    "properties": {
                        "title": {"type": "string"},
                        "date": {"type": "string"},
                        "description": {"type": "string"},
                        "venue": {"type": "string"},
                        "address": {"type": "string"},
                        "start_time": {"type": "string"},
                    },
                }
            },
        }
    ),
)

print(result.json_content)

import Olostep from 'olostep'

const client = new Olostep({ apiKey: 'YOUR_REAL_KEY' })

const result = await client.scrapes.create({
  url: 'https://www.berklee.edu/events/stefano-marchese-friends',
  formats: ['markdown', 'json'],
  llmExtract: {
    schema: {
      type: 'object',
      properties: {
        event: {
          type: 'object',
          properties: {
            title: { type: 'string' },
            date: { type: 'string' },
            description: { type: 'string' },
            venue: { type: 'string' },
            address: { type: 'string' },
            start_time: { type: 'string' },
          },
        },
      },
    },
  },
})

console.log(result.json_content)

curl -s -X POST "https://api.olostep.com/v1/scrapes" \
  -H "Authorization: Bearer $OLOSTEP_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "url_to_scrape": "https://www.berklee.edu/events/stefano-marchese-friends",
    "formats": ["json"],
    "llm_extract": {
      "prompt": "Extract the event title, date, description, venue, address, and start time from the page."
    }
  }'

olostep scrape "https://www.berklee.edu/events/stefano-marchese-friends" \
  --formats json \
  --payload-json '{"llm_extract":{"prompt":"Extract the event title, date, description, venue, address, and start time from the page."}}'

const res = await fetch('https://api.olostep.com/v1/scrapes', {
  method: 'POST',
  headers: { 'Authorization': 'Bearer <YOUR_API_KEY>', 'Content-Type': 'application/json' },
  body: JSON.stringify({
    url_to_scrape: 'https://www.berklee.edu/events/stefano-marchese-friends',
    formats: ['json'],
    llm_extract: {
      prompt: 'Extract the event title, date, description, venue, address, and start time from the page.'
    }
  })
})
console.log(await res.json())

import requests, json

endpoint = "https://api.olostep.com/v1/scrapes"
payload = {
  "url_to_scrape": "https://www.berklee.edu/events/stefano-marchese-friends",
  "formats": ["markdown", "json"],
  "llm_extract": {
    "schema": {
      "type": "object",
      "properties": {
        "event": {
          "type": "object",
          "properties": {
            "title": {"type": "string"},
            "date": {"type": "string"},
            "description": {"type": "string"},
            "venue": {"type": "string"},
            "address": {"type": "string"},
            "start_time": {"type": "string"}
          }
        }
      }
    }
  }
}
headers = {
    "Authorization": "Bearer <YOUR_API_KEY>",
    "Content-Type": "application/json"
}
res = requests.post(endpoint, json=payload, headers=headers)
print(json.dumps(res.json(), indent=2))

Opmerking: in de Python SDK is result.json_content al een dict. In de Node SDK en de ruwe API is het een JSON-string, dus parse het (JSON.parse / json.loads) als je een object nodig hebt. Prijzen: llm_extract kost 10 credits per scrape. Om de kosten te verlagen, kun je je eigen API-sleutels gebruiken of gebruiksgebaseerde prijzen inschakelen. Neem contact op met info@olostep.com om toegang te krijgen.

Links op de pagina extraheren

Met de links_on_page optie kun je alle links extraheren die op de pagina aanwezig zijn die je scrapt. Het accepteert de volgende parameters om de geëxtraheerde links te filteren en te ordenen:

absolute_links (boolean, standaard: true): Wanneer waar, retourneert het volledige URL’s (bijv. https://example.com/page) in plaats van relatieve paden (bijv. /page).
query_to_order_links_by (string): Ordent de geretourneerde links op hun gelijkenis met de verstrekte querytekst, waarbij de meest relevante overeenkomsten eerst worden geprioriteerd.
include_links (array van strings): Filter geëxtraheerde links met behulp van glob-patronen. Gebruik patronen zoals *.pdf om bestandsextensies te matchen, /blog/* voor specifieke paden, of volledige URL’s zoals https://example.com/*. Ondersteunt wildcards (*), tekenklassen ([a-z]), en alternatie ({pattern1,pattern2}).
exclude_links (array van strings): Sluit specifieke links uit met behulp van glob-patronen, volgens dezelfde syntaxis als include_links.

Interactie met de pagina met Acties

Voer acties uit voordat je gaat scrapen om te communiceren met dynamische sites. Ondersteunde acties:

wait met milliseconds
click met selector
fill_input met selector en value
scroll met direction en amount

Het is vaak nuttig om wait te gebruiken voor/na andere acties om de pagina de tijd te geven om te laden.

Voorbeeld

from olostep import FillInputAction, Olostep, WaitAction

client = Olostep(api_key="YOUR_REAL_KEY")

result = client.scrapes.create(
    url_to_scrape="https://example.com/login",
    formats=["markdown"],
    actions=[
        FillInputAction(selector="input[type=email]", value="john@example.com"),
        WaitAction(milliseconds=500),
        FillInputAction(selector="input[type=password]", value="secret"),
        {"type": "click", "selector": "button[type=\"submit\"]"},
        WaitAction(milliseconds=1500),
    ],
)

print(result.markdown_content)

import Olostep from 'olostep'

const client = new Olostep({ apiKey: 'YOUR_REAL_KEY' })

const result = await client.scrapes.create({
  url: 'https://example.com/login',
  formats: ['markdown'],
  actions: [
    { type: 'fill_input', selector: 'input[type=email]', value: 'john@example.com' },
    { type: 'wait', milliseconds: 500 },
    { type: 'fill_input', selector: 'input[type=password]', value: 'secret' },
    { type: 'click', selector: 'button[type="submit"]' },
    { type: 'wait', milliseconds: 1500 },
  ],
})

console.log(result.markdown_content)

curl -s -X POST "https://api.olostep.com/v1/scrapes" \
  -H "Authorization: Bearer $OLOSTEP_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "url_to_scrape": "https://example.com/login",
    "formats": ["markdown"],
    "actions": [
      { "type": "fill_input", "selector": "input[type=email]", "value": "john@example.com" },
      { "type": "wait", "milliseconds": 500 },
      { "type": "fill_input", "selector": "input[type=password]", "value": "secret" },
      { "type": "click", "selector": "button[type=\"submit\"]" },
      { "type": "wait", "milliseconds": 1500 }
    ]
  }'

# Voor complexe opties zoals acties, gebruik --payload-file met een JSON-bestand
olostep scrape "https://example.com/login" \
  --formats markdown \
  --payload-file actions.json

# Waar actions.json bevat:
# {
#   "actions": [
#     {"type": "fill_input", "selector": "input[type=email]", "value": "john@example.com"},
#     {"type": "wait", "milliseconds": 500},
#     {"type": "fill_input", "selector": "input[type=password]", "value": "secret"},
#     {"type": "click", "selector": "button[type=\"submit\"]"},
#     {"type": "wait", "milliseconds": 1500}
#   ]
# }

const res = await fetch('https://api.olostep.com/v1/scrapes', {
  method: 'POST',
  headers: { 'Authorization': 'Bearer <YOUR_API_KEY>', 'Content-Type': 'application/json' },
  body: JSON.stringify({
    url_to_scrape: 'https://example.com/login',
    formats: ['markdown'],
    actions: [
      { type: 'fill_input', selector: 'input[type=email]', value: 'john@example.com' },
      { type: 'wait', milliseconds: 500 },
      { type: 'fill_input', selector: 'input[type=password]', value: 'secret' },
      { type: 'click', selector: 'button[type="submit"]' },
      { type: 'wait', milliseconds: 1500 }
    ]
  })
})
console.log(await res.json())

import requests, json

endpoint = "https://api.olostep.com/v1/scrapes"
payload = {
  "url_to_scrape": "https://example.com/login",
  "formats": ["markdown"],
  "actions": [
    {"type": "fill_input", "selector": "input[type=email]", "value": "john@example.com"},
    {"type": "wait", "milliseconds": 500},
    {"type": "fill_input", "selector": "input[type=password]", "value": "secret"},
    {"type": "click", "selector": "button[type=\"submit\"]"},
    {"type": "wait", "milliseconds": 1500}
  ]
}
headers = {
    "Authorization": "Bearer <YOUR_API_KEY>", 
    "Content-Type": "application/json"
}
res = requests.post(endpoint, json=payload, headers=headers)
print(json.dumps(res.json(), indent=2))

De respons zal alle gevraagde formaten bevatten (bijv. markdown_content).

Gebruikscases

Hieronder staan enkele praktische toepassingen van klanten die de /scrapes endpoint gebruiken.

Content Analyse & Onderzoek

Concurrentieanalyse: Productdetails, prijzen en functies van concurrentenwebsites extraheren
Marktonderzoek: Landingspagina’s, productbeschrijvingen en klantgetuigenissen analyseren
Academisch Onderzoek: Specifieke gegevens verzamelen van wetenschappelijke publicaties of onderzoeksportalen
Juridische Documentatie: Casestudies, regelgeving of juridische precedenten van officiële websites extraheren

E-commerce & Detailhandel

Dynamische Prijsstrategieën: Real-time productprijzen van concurrerende winkels verkrijgen
Productinformatiebeheer: Gedetailleerde specificaties en beschrijvingen extraheren
Voorraad/Inventaris Monitoring: Productbeschikbaarheid bij andere retailers controleren
Review Analyse: Consumentenfeedback en sentiment voor specifieke producten verzamelen

Marketing & Contentcreatie

Contentcuratie: Relevante artikelen en blogposts voor nieuwsbrieven extraheren
SEO Analyse: Het gebruik van zoekwoorden, meta beschrijvingen en pagina-structuur van concurrenten onderzoeken
Leadgeneratie: Contactinformatie van bedrijvengidsen of bedrijfspagina’s extraheren
Influencer Onderzoek: Betrokkenheidsstatistieken en contentstijlen van influencerprofielen verzamelen
Gepersonaliseerde Social Media generatie: AI-gestuurde social media marketing creëren door klantenwebsites te analyseren

Data Toepassingen

AI Trainingsdataverzameling: Specifieke voorbeelden voor machine learning modellen verzamelen
Aangepaste Kennisbank Bouwen: Documentatie of instructies van softwarewebsites extraheren
Historische Data Archieven: Website-inhoud op specifieke momenten in de tijd bewaren
Gestructureerde Data Extractie: Webinhoud omzetten in geformatteerde datasets voor analyse

Monitoring & Alerts

Regelgevingsnaleving Monitoring: Wijzigingen op juridische of regelgevende websites volgen
Crisisbeheer: Nieuwswebsites monitoren voor vermeldingen van specifieke evenementen of organisaties
Evenement Volgen: Details over aankomende evenementen van locatie- of organisatorwebsites extraheren
Service Status Monitoring: Servicestatuspagina’s controleren voor specifieke platforms of tools

Uitgeverij & Media

Nieuwsaggregatie: Breaking news van officiële bronnen extraheren
Mediamonitoring: Specifieke onderwerpen op nieuwswebsites volgen
Contentverificatie: Informatie extraheren om claims of uitspraken te controleren
Multimedia Extractie: Ingebedde video’s, afbeeldingen of audio voor mediatheken verzamelen

Financiële Toepassingen

Investeringsonderzoek: Financiële overzichten of jaarverslagen van bedrijfswebsites extraheren
Economische Indicatoren: Economische gegevens van overheids- of financiële instellingwebsites verzamelen
Cryptocurrency Data: Real-time prijs- en marktkapitalisatie-informatie extraheren
Financiële Nieuws Analyse: Financiële nieuwssites monitoren voor specifieke marktsignalen

Technische Toepassingen

API Documentatie Extractie: Technische documentatie voor referentie verzamelen
Integratietesten: Website-elementen extraheren om derde partij integraties te verifiëren
Toegankelijkheidstesten: Website-structuur analyseren voor naleving van toegankelijkheidsnormen
Webarchief Creatie: Volledige website-inhoud vastleggen voor historische bewaring

Integratie Scenario’s

CRM Systemen: Klantprofielen verbeteren met gegevens van bedrijfswebsites of Linkedin
Content Management Systemen: Relevante externe inhoud importeren
Business Intelligence Tools: Interne gegevens aanvullen met externe marktinformatie
Project Management Software: Specificaties of vereisten van klantwebsites extraheren
Aangepaste Dashboards: Geëxtraheerde gegevens naast interne statistieken weergeven

Foutafhandeling

Alle fouten volgen een gedeelde envelopvorm. Controleer error.type en error.code om programmatisch te vertakken:

{
  "id": "error_abc123",
  "object": "error",
  "created": 1745673871,
  "url": "https://example.com",
  "metadata": {},
  "error": {
    "type": "...",
    "code": "...",
    "message": "..."
  }
}

HTTP	`error.type`	`error.code`	Betekenis
400	`invalid_request_error`	`dns_resolution_failed`	Het domein bestaat niet of de URL bevat een typfout.
400	`invalid_request_error`	`invalid_url`	De URL is verkeerd gevormd.
502	`invalid_request_error`	`tls_error`	De website heeft een ongeldig of incompatibel TLS/SSL-certificaat. `error.detail` bevat de laag-niveau SSL-code.
504	`request_timeout`	`scrape_poll_timeout`	De scrape is niet voltooid binnen het ~55-seconden wachttijd budget.

DNS-fout (400)

Het domein lost niet op. Controleer de URL op typfouten.

{
  "error": {
    "type": "invalid_request_error",
    "code": "dns_resolution_failed",
    "message": "De URL bevat een typfout, of het domein bestaat niet."
  }
}

TLS/SSL-fout (502)

De doelwebsite heeft een gebroken of incompatibele HTTPS-configuratie. error.detail biedt de specifieke SSL-foutcode voor diagnostiek; error.code is altijd tls_error.

{
  "error": {
    "type": "invalid_request_error",
    "code": "tls_error",
    "detail": "err_ssl_tlsv1_alert_internal_error",
    "message": "De website sloot of weigerde de TLS-handshake. De server kan verkeerd geconfigureerd zijn of een niet-ondersteunde SSL/TLS-versie gebruiken."
  }
}

Aanvraag time-out (504)

De scrape is niet voltooid binnen het wachttijd budget. De pagina kan traag zijn, bot-beschermd, of tijdelijk niet beschikbaar. Deze respons is veilig om opnieuw te proberen.

{
  "error": {
    "type": "request_timeout",
    "code": "scrape_poll_timeout",
    "message": "Aanvraag time-out terwijl gewacht werd op scrape resultaat. De pagina kan traag zijn, geblokkeerd voor onze fetchers, of tijdelijk niet beschikbaar."
  }
}

Prijzen

Scrape kost standaard 1 credit. Als je ook parsers gebruikt, variëren de kosten per parser (1-5 credits). Als je LLM extract gebruikt, kost het 10 credits.

Aan de slag

Functies

Saldo & Facturering

Scrape

Een URL scrapen

Installatie

Gebruik

Respons

Caching

Hoe het werkt

Versheid en `max_age`

Gebruik Voorbeelden

Wanneer wordt de cache overgeslagen?

Opslag

Gebruik

Links extraheren

Scrape Formaten

Gestructureerde data extraheren

Een Parser gebruiken (aanbevolen voor schaal)

LLM-extractie gebruiken (schema en/of prompt)

Links op de pagina extraheren

Interactie met de pagina met Acties

Voorbeeld

Gebruikscases

Content Analyse & Onderzoek

E-commerce & Detailhandel

Marketing & Contentcreatie

Data Toepassingen

Monitoring & Alerts

Uitgeverij & Media

Financiële Toepassingen

Technische Toepassingen

Integratie Scenario’s

Foutafhandeling

DNS-fout (400)

TLS/SSL-fout (502)

Aanvraag time-out (504)

Prijzen

​Een URL scrapen

​Installatie

​Gebruik

​Respons

​Caching

​Hoe het werkt

​Versheid en max_age

​Gebruik Voorbeelden

​Wanneer wordt de cache overgeslagen?

​Opslag

​Gebruik

​Links extraheren

​Scrape Formaten

​Gestructureerde data extraheren

​Een Parser gebruiken (aanbevolen voor schaal)

​LLM-extractie gebruiken (schema en/of prompt)

​Links op de pagina extraheren

​Interactie met de pagina met Acties

​Voorbeeld

​Gebruikscases

​Content Analyse & Onderzoek

​E-commerce & Detailhandel

​Marketing & Contentcreatie

​Data Toepassingen

​Monitoring & Alerts

​Uitgeverij & Media

​Financiële Toepassingen

​Technische Toepassingen

​Integratie Scenario’s

​Foutafhandeling

​DNS-fout (400)

​TLS/SSL-fout (502)

​Aanvraag time-out (504)

​Prijzen

Een URL scrapen

Installatie

Gebruik

Respons

Caching

Hoe het werkt

Versheid en `max_age`

Gebruik Voorbeelden

Wanneer wordt de cache overgeslagen?

Opslag

Gebruik

Links extraheren

Scrape Formaten

Gestructureerde data extraheren

Een Parser gebruiken (aanbevolen voor schaal)

LLM-extractie gebruiken (schema en/of prompt)

Links op de pagina extraheren

Interactie met de pagina met Acties

Voorbeeld

Gebruikscases

Content Analyse & Onderzoek

E-commerce & Detailhandel

Marketing & Contentcreatie

Data Toepassingen

Monitoring & Alerts

Uitgeverij & Media

Financiële Toepassingen

Technische Toepassingen

Integratie Scenario’s

Foutafhandeling

DNS-fout (400)

TLS/SSL-fout (502)

Aanvraag time-out (504)

Prijzen