> ## Documentation Index
> Fetch the complete documentation index at: https://docs.olostep.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Scrape

> Zet elke URL om in LLM-klaar Markdown, HTML, screenshots, PDF’s of gestructureerde JSON.

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

* Levert schone markdown, gestructureerde data, screenshots of html
* Haal JSON op via [Parsers](/features/structured-content/parsers) of [LLM extractie](/features/structured-content/llm-extraction)
* Behandelt dynamische inhoud: js-gerenderde sites, login flows via acties, PDF's

Voor API-details zie de [Scrape Endpoint API Referentie](/api-reference/scrapes/create).

## Een URL scrapen

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

### Installatie

<CodeGroup>
  ```python Python theme={null}
  pip install olostep
  ```

  ```javascript Node theme={null}
  npm install olostep
  ```

  ```bash cURL theme={null}
  # curl is standaard beschikbaar op macOS, Linux en Windows
  ```

  ```javascript Node (API) theme={null}
  npm install node-fetch
  ```

  ```bash Python (API) theme={null}
  pip install requests
  ```
</CodeGroup>

### 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 selectoren), en `country`.

<CodeGroup>
  ```python Python theme={null}
  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)
  ```

  ```js Node theme={null}
  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)
  ```

  ```bash cURL theme={null}
  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"]
    }'
  ```

  ```bash CLI theme={null}
  olostep scrape "https://en.wikipedia.org/wiki/Alexander_the_Great" \
    --formats markdown,html
  ```

  ```js Node (API) theme={null}
  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)
  ```

  ```python Python (API) theme={null}
  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))
  ```
</CodeGroup>

### Reactie

De API retourneert een `scrape` object als reactie.

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

```json theme={null}
{
  "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 verse match wordt gevonden, wordt de inhoud direct vanuit Olostep's opslag geserveerd zonder een nieuwe browserscrape 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 snelheidsverbetering.
* **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 leeftijd van de inhoud in **seconden**. Als er een gecachte kopie bestaat die nieuwer is dan `max_age` seconden, wordt deze uit de cache geserveerd. |

* **Standaard API Gedrag (`max_age: 0`):** Elke API-aanvraag triggert een verse scrape.
* **Standaard Playground Gedrag:** In de dashboard playground is `max_age` standaard 24 uur (`86400` seconden) om dubbele scrapes te voorkomen en credits te besparen terwijl je bouwt en test.
* **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.

### Gebruiksvoorbeelden

<CodeGroup>
  ```python Python theme={null}
  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
  )
  ```

  ```js Node theme={null}
  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,
  })
  ```

  ```bash cURL theme={null}
  # 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
    }'
  ```

  ```js Node (API) theme={null}
  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)
  ```

  ```python Python (API) theme={null}
  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))
  ```
</CodeGroup>

### Wanneer wordt de cache overgeslagen?

De cache wordt automatisch omzeild (waardoor een live scrape wordt geforceerd) voor functies die unieke sessies, real-time visuele outputs of aangepaste bestandsafhandeling vereisen:

* **Interactieve sessies:** Aanvragen met `session_id` of het laden van een aangepaste browser `context`.
* **Visuals:** Visualisatietools en screenshots (`htmlVisualizer`).
* **Speciale bestandstypen:** Binaire bestanddownloads of ruwe PDF-weergave.
* **Debugging & Netwerk:** Het vastleggen van `network_calls` of het gebruik van asynchrone parserjobs.

## 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.

```json theme={null}
"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`: herschikt de geretourneerde links op relevantie voor deze tekst.

<Note>
  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 onderdeel zijn van het pad. Om de index ook op te nemen, gebruik `"/blog*"` of `"{/blog,/blog/**}"`.
</Note>

## 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 Parsers of LLM extractie.

### Een Parser gebruiken (aanbevolen voor schaal)

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

<CodeGroup>
  ```python Python theme={null}
  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)
  ```

  ```js Node theme={null}
  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)
  ```

  ```bash cURL theme={null}
  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"}
    }'
  ```

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

  ```js Node (API) theme={null}
  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())
  ```

  ```python Python (API) theme={null}
  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))
  ```
</CodeGroup>

Olostep heeft een paar vooraf gebouwde parsers voor [populaire websites](https://www.olostep.com/store) 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 updaten 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 data extraheren op basis van de prompt en zelf de datastructuur bepalen.

<CodeGroup>
  ```python Python theme={null}
  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={
              "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)
  ```

  ```js Node theme={null}
  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: {
        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)
  ```

  ```bash cURL theme={null}
  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."
      }
    }'
  ```

  ```bash CLI theme={null}
  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."}}'
  ```

  ```js Node (API) theme={null}
  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())
  ```

  ```python Python (API) theme={null}
  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": {
        "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))
  ```
</CodeGroup>

Opmerking: `result.json_content` retourneert een gestringde JSON. Parse het in je code 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 prijsstelling op basis van gebruik inschakelen. Neem contact op met [info@olostep.com](mailto:info@olostep.com) om toegang te krijgen.

## Links op de pagina extraheren

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

* `absolute_links` (boolean, standaard: `true`): Wanneer true, 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 opgegeven 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 scrapt 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

<CodeGroup>
  ```python Python theme={null}
  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)
  ```

  ```js Node theme={null}
  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)
  ```

  ```bash cURL theme={null}
  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 }
      ]
    }'
  ```

  ```bash CLI theme={null}
  # 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}
  #   ]
  # }
  ```

  ```js Node (API) theme={null}
  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())
  ```

  ```python Python (API) theme={null}
  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))
  ```
</CodeGroup>

De reactie zal alle gevraagde formaten bevatten (bijv. `markdown_content`).

## Gebruikscases

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

### Inhoudsanalyse & Onderzoek

* **Concurrentieanalyse**: Haal productdetails, prijzen en functies van concurrentenwebsites
* **Marktonderzoek**: Analyseer landingspagina's, productbeschrijvingen en klantgetuigenissen
* **Academisch Onderzoek**: Verzamel specifieke data van wetenschappelijke publicaties of onderzoeksportalen
* **Juridische Documentatie**: Haal casestudies, regelgeving of juridische precedenten van officiële websites

### E-commerce & Detailhandel

* **Dynamische Prijsstrategieën**: Verkrijg real-time productprijzen van concurrerende winkels
* **Productinformatiebeheer**: Haal gedetailleerde specificaties en beschrijvingen op
* **Voorraad/Inventaris Monitoring**: Controleer productbeschikbaarheid bij andere retailers
* **Review Analyse**: Verzamel consumentenfeedback en sentiment voor specifieke producten

### Marketing & Contentcreatie

* **Content Curation**: Haal relevante artikelen en blogposts op voor nieuwsbrieven
* **SEO Analyse**: Onderzoek het gebruik van zoekwoorden, metabeschrijvingen en paginavormgeving van concurrenten
* **Leadgeneratie**: Haal contactinformatie van bedrijvengidsen of bedrijfspagina's
* **Influencer Onderzoek**: Verzamel betrokkenheidsstatistieken en contentstijlen van influencerprofielen
* **Gepersonaliseerde Sociale Media generatie**: Creëer AI-gestuurde sociale mediamarketing door klantwebsites te analyseren

### Data Toepassingen

* **AI Trainingsdata Verzameling**: Verzamel specifieke voorbeelden voor machine learning modellen
* **Aangepaste Kennisbank Bouwen**: Haal documentatie of instructies van softwarewebsites
* **Historische Data Archieven**: Bewaar website-inhoud op specifieke tijdstippen
* **Gestructureerde Data Extractie**: Transformeer webinhoud in geformatteerde datasets voor analyse

### Monitoring & Waarschuwingen

* **Regelgevingsnaleving Monitoring**: Volg wijzigingen op juridische of regelgevende websites
* **Crisisbeheer**: Monitor nieuwssites voor vermeldingen van specifieke evenementen of organisaties
* **Evenementen Volgen**: Haal details over aankomende evenementen van locatie- of organisatorenwebsites
* **Service Status Monitoring**: Controleer servicestatuspagina's voor specifieke platforms of tools

### Publicatie & Media

* **Nieuwsaggregatie**: Haal breaking news van officiële bronnen
* **Media Monitoring**: Volg specifieke onderwerpen op nieuwssites
* **Inhoudsverificatie**: Haal informatie op om claims of verklaringen te factchecken
* **Multimedia Extractie**: Verzamel ingesloten video's, afbeeldingen of audio voor mediatheken

### Financiële Toepassingen

* **Investeringsonderzoek**: Haal financiële overzichten of jaarverslagen van bedrijfswebsites
* **Economische Indicatoren**: Verzamel economische data van overheids- of financiële instellingenwebsites
* **Cryptocurrency Data**: Haal real-time prijs- en marktkapitalisatie-informatie op
* **Financiële Nieuws Analyse**: Monitor financiële nieuwssites voor specifieke marktsignalen

### Technische Toepassingen

* **API Documentatie Extractie**: Verzamel technische documentatie voor referentie
* **Integratietesten**: Haal website-elementen op om derde partij integraties te verifiëren
* **Toegankelijkheidstesten**: Analyseer website-structuur voor naleving van toegankelijkheidsnormen
* **Webarchief Creatie**: Leg volledige website-inhoud vast voor historische bewaring

### Integratiescenario's

* **CRM Systemen**: Verrijk klantprofielen met data van bedrijfswebsites of Linkedin
* **Content Management Systemen**: Importeer relevante externe inhoud
* **Business Intelligence Tools**: Vul interne data aan met externe marktinformatie
* **Project Management Software**: Haal specificaties of vereisten van klantwebsites op
* **Aangepaste Dashboards**: Toon geëxtraheerde data naast interne statistieken

## Foutafhandeling

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

```json theme={null}
{
  "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 low-level 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.

```json theme={null}
{
  "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 diagnose; `error.code` is altijd `tls_error`.

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

### Aanvraag timeout (504)

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

```json theme={null}
{
  "error": {
    "type": "request_timeout",
    "code": "scrape_poll_timeout",
    "message": "Aanvraag time-out tijdens het wachten 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](/features/structured-content/parsers) doorgeeft, variëren de kosten per parser (1-5 credits). Als je [LLM extract](/features/structured-content/llm-extraction) gebruikt, kost het 10 credits.