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

> Verwandle jede URL in LLM-bereites Markdown, HTML, Screenshots, PDFs oder strukturiertes JSON.

Über den Olostep `/v1/scrapes` Endpunkt kannst du LLM-freundliches Markdown, HTML, Text, Screenshots oder strukturiertes JSON in Echtzeit aus jeder URL extrahieren.

* Gibt sauberes Markdown, strukturierte Daten, Screenshots oder HTML aus
* Extrahiere JSON durch [Parsers](/features/structured-content/parsers) oder [LLM-Extraktion](/features/structured-content/llm-extraction)
* Handhabt dynamische Inhalte: JS-gerenderte Seiten, Login-Flows über Aktionen, PDFs

Für API-Details siehe die [Scrape Endpoint API Reference](/api-reference/scrapes/create).

## Eine URL scrapen

Nutze den `/v1/scrapes` Endpunkt, um eine einzelne URL zu scrapen und Ausgabeformate zu wählen.

### Installation

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

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

  ```bash cURL theme={null}
  # curl ist standardmäßig auf macOS, Linux und Windows verfügbar
  ```

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

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

### Verwendung

Du kannst den Endpunkt verwenden, um eine einzelne URL zu scrapen und Ausgabeformate zu wählen. Die obligatorischen Parameter sind `url_to_scrape` und `formats`.

Einige andere häufige Parameter sind `wait_before_scraping` (in Millisekunden), `remove_css_selectors` (Standard, keine oder ein Array von Selektoren) und `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>

### Antwort

Die API gibt ein `scrape` Objekt als Antwort zurück.

Das `scrape` hat einige Eigenschaften wie `id` und `result`.

Das `result` Objekt hat die folgenden Felder (je nach `formats` Parameter können einige null sein):

* `html_content`: der HTML-Inhalt der Seite. Gib `formats: ["html"]` an, um dies zu erhalten.
* `markdown_content`: der MD-Inhalt der Seite. Gib `formats: ["markdown"]` an, um dies zu erhalten.
* `text_content`: der Textinhalt der Seite. Gib `formats: ["text"]` an, um dies zu erhalten.
* `json_content`: der JSON-Inhalt der Seite. Gib `formats: ["json"]` an, um dies zu erhalten und auch einen `parser` oder `llm_extract` Parameter bereitzustellen.
* `screenshot_hosted_url`: die gehostete URL des Screenshots.
* `html_hosted_url`: die gehostete URL des HTML-Inhalts
* `markdown_hosted_url`: die gehostete URL des Markdown-Inhalts
* `json_hosted_url`: die gehostete URL des JSON-Inhalts
* `text_hosted_url`: die gehostete URL des Textinhalts
* `links_on_page`: die Links auf der Seite
* `page_metadata`: die Metadaten der Seite

```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

Um die Geschwindigkeit zu optimieren, bietet Olostep eine optionale gemeinsame Caching-Schicht für HTML-, Markdown-, Text- und geparste JSON-Ergebnisse.

### Wie es funktioniert

Wenn ein Scrape angefordert wird, prüft Olostep, ob ein passendes Scrape mit denselben Parametern bereits existiert. Wenn ein ausreichend frisches Match gefunden wird, wird der Inhalt sofort aus Olosteps Speicher bereitgestellt, ohne einen neuen Browser-Scrape zu starten.

* **Gemeinsamer Cache:** Der Cache wird weltweit geteilt. Wenn eine andere Anfrage genau dieselbe URL mit genau derselben Konfiguration innerhalb deines Frischefensters gescrapt hat, profitierst du von der Geschwindigkeitssteigerung.
* **Nachbearbeitung ist weiterhin live:** Operationen wie `llm_extract` und `links_on_page` Filter werden *on-the-fly* auf dem zwischengespeicherten Dokument ausgeführt. Du cachest nur die Kernseitenabfrage, wodurch deine strukturierten Extraktionen dynamisch bleiben.

### Frische und `max_age`

Standardmäßig führt die Produktions-API immer einen Live-Scrape durch, um Echtzeitgenauigkeit zu gewährleisten. Du kannst das Caching mit dem `max_age` Parameter aktivieren.

| Parameter | Typ | Standard | Beschreibung |
| - | - | - | - |
| `max_age` | `integer` | `0` | Akzeptables Inhaltsalter in **Sekunden**. Wenn eine zwischengespeicherte Kopie existiert und neuer als `max_age` Sekunden ist, wird sie aus dem Cache bereitgestellt. |

* **Standard-API-Verhalten (`max_age: 0`):** Jede API-Anfrage löst einen frischen Scrape aus.
* **Standard-Playground-Verhalten:** Im Dashboard-Playground ist `max_age` standardmäßig auf 24 Stunden (`86400` Sekunden) gesetzt.
* **Maximales Alter:** Der Cache hat ein hartes Limit von **7 Tagen** (`604800` Sekunden). Jede über diesem Limit angeforderte `max_age` wird auf maximal 7 Tage zurückgesetzt.

### Anwendungsbeispiele

<CodeGroup>
  ```python Python theme={null}
  from olostep import Olostep

  client = Olostep(api_key="YOUR_REAL_KEY")

  # Opt-in zum Caching: Akzeptiere Ergebnisse bis zu 1 Tag (86400 Sekunden) alt
  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' })

  // Opt-in zum Caching: Akzeptiere Ergebnisse bis zu 1 Tag (86400 Sekunden) alt
  const result = await client.scrapes.create({
    url: 'https://example.com',
    formats: ['markdown'],
    maxAge: 86400,
  })
  ```

  ```bash cURL theme={null}
  # Opt-in zum Caching: Akzeptiere Ergebnisse bis zu 1 Stunde (3600 Sekunden) alt
  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 // Akzeptiere Ergebnisse bis zu 1 Tag (86400 Sekunden) alt
  }
  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 # Akzeptiere Ergebnisse bis zu 1 Tag (86400 Sekunden) alt
  }
  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>

### Wann wird der Cache umgangen?

Der Cache wird automatisch umgangen (was einen Live-Scrape erzwingt), wenn deine Anfrage Folgendes benötigt:

* **Interaktive Sitzungen:** Anfragen, die `session_id` verwenden oder einen benutzerdefinierten Browser `context` laden.
* **Screenshots:** Jede Anfrage, die `screenshot` in Formaten enthält oder die Screenshot-Option setzt, umgeht den Cache.
* **Spezielle Dateitypen:** Binäre Dateidownloads oder rohe PDF-Darstellung.
* **Debugging & Netzwerk:** Erfassen von `network_calls` oder Verwendung von asynchronen Parser-Jobs.

## Links extrahieren

Gib ein `links_on_page` Objekt in der Anfrage an, um die auf der Seite gefundenen Links zu sammeln. Alle Links werden als absolute URLs zurückgegeben.

```json theme={null}
"links_on_page": {
  "include_links": ["/blog/*"],
  "exclude_links": ["*.pdf"],
  "query_to_order_links_by": "pricing"
}
```

* `include_links` / `exclude_links`: Glob-Muster, die mit dem URL-Pfad jedes Links abgeglichen werden.
* `query_to_order_links_by`: sortiert die zurückgegebenen Links nach Relevanz zu diesem Text.

<Note>
  Glob-Muster passen auf Pfadsegmente. Ein einzelnes `*` überschreitet **nicht** `/`, daher passt `"/blog/*"` auf `"/blog/post-1"`, aber **nicht** auf den Index `"/blog"` selbst — und es passt nie auf `"/blog?tag=x"`, da Abfragezeichenfolgen nicht Teil des Pfads sind. Um auch den Index einzuschließen, verwende `"/blog*"` oder `"{/blog,/blog/**}"`.
</Note>

## Scrape-Formate

Wähle ein oder mehrere Ausgabeformate über `formats`:

* `markdown`: LLM-freundliches Markdown
* `html`: bereinigtes HTML
* `text`: Klartext
* `json`: strukturiertes Ausgabeformat (über Parser oder llm\_extract)
* `raw_pdf`: rohe PDF-Bytes, die zur gehosteten URL extrahiert werden
* `screenshot`: über Aktionen festgelegt, um einen Screenshot zu erfassen und eine gehostete URL zurückzugeben

Ausgabeschlüssel werden innerhalb von `result` als `*_content` Felder und eine `*_hosted_url` zurückgegeben.

## Strukturierte Daten extrahieren

Du kannst strukturiertes JSON auf zwei Arten extrahieren: mit Parsers oder LLM-Extraktion.

### Verwendung eines Parsers (empfohlen für Skalierung)

Definiere `formats: ["json"]` und gib eine Parser `id` an.

<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 hat einige vorgefertigte Parser für [beliebte Websites](https://www.olostep.com/store), aber du kannst auch deine eigenen Parser über das Dashboard erstellen oder unser Team bitten, dies für dich zu tun.

Parser sind selbstheilend und aktualisieren sich selbst auf die neueste Version der Website.

### Verwendung von LLM-Extraktion (Schema und/oder Prompt)

Gib `llm_extract` mit einem JSON-Schema (`schema`) und/oder einer natürlichen Sprachinstruktion (`prompt`) an. Du kannst beide Parameter übergeben, aber wenn beide bereitgestellt werden, hat `schema` Vorrang.

Wenn du stattdessen nur einen `prompt` übergibst, extrahiert das LLM die Daten basierend auf dem Prompt und entscheidet selbst über die Datenstruktur.

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

Hinweis: `result.json_content` gibt ein stringifiziertes JSON zurück. Analysiere es in deinem Code, wenn du ein Objekt benötigst.

**Preise:** `llm_extract` kostet 10 Credits pro Scrape. Um die Kosten zu senken, kannst du deine eigenen API-Schlüssel verwenden oder nutzungsbasierte Preise aktivieren. Kontaktiere [info@olostep.com](mailto:info@olostep.com), um Zugang zu erhalten.

## Links auf der Seite extrahieren

Mit der `links_on_page` Option kannst du alle auf der gescrapten Seite vorhandenen Links extrahieren. Es akzeptiert die folgenden Parameter, um die extrahierten Links zu filtern und zu sortieren:

* `absolute_links` (boolean, Standard: `true`): Wenn true, werden vollständige URLs (z.B. `https://example.com/page`) anstelle von relativen Pfaden (z.B. `/page`) zurückgegeben.
* `query_to_order_links_by` (string): Sortiert die zurückgegebenen Links nach ihrer Ähnlichkeit mit dem bereitgestellten Abfragetext, wobei die relevantesten Übereinstimmungen zuerst priorisiert werden.
* `include_links` (Array von Strings): Filtere extrahierte Links mit Glob-Mustern. Verwende Muster wie `*.pdf`, um Dateierweiterungen zu matchen, `/blog/*` für bestimmte Pfade oder vollständige URLs wie `https://example.com/*`. Unterstützt Platzhalter (`*`), Zeichenklassen (`[a-z]`) und Alternation (`{pattern1,pattern2}`).
* `exclude_links` (Array von Strings): Schließe spezifische Links mit Glob-Mustern aus, die derselben Syntax wie `include_links` folgen.

## Mit der Seite interagieren mit Aktionen

Führe Aktionen vor dem Scrapen durch, um mit dynamischen Seiten zu interagieren. Unterstützte Aktionen:

* `wait` mit `milliseconds`
* `click` mit `selector`
* `fill_input` mit `selector` und `value`
* `scroll` mit `direction` und `amount`

Es ist oft nützlich, `wait` vor/nach anderen Aktionen zu verwenden, um der Seite Zeit zum Laden zu geben.

### Beispiel

<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}
  # Für komplexe Optionen wie Aktionen, verwende --payload-file mit einer JSON-Datei
  olostep scrape "https://example.com/login" \
    --formats markdown \
    --payload-file actions.json

  # Wo actions.json enthält:
  # {
  #   "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>

Die Antwort wird alle angeforderten Formate (z.B. `markdown_content`) enthalten.

## Anwendungsfälle

Im Folgenden sind einige praktische Anwendungen von Kunden aufgeführt, die den `/scrapes` Endpunkt nutzen.

### Inhaltsanalyse & Forschung

* **Wettbewerbsanalyse**: Extrahiere Produktdetails, Preise und Funktionen von Wettbewerber-Websites
* **Marktforschung**: Analysiere Landingpages, Produktbeschreibungen und Kundenreferenzen
* **Akademische Forschung**: Sammle spezifische Daten aus wissenschaftlichen Publikationen oder Forschungsportalen
* **Rechtsdokumentation**: Extrahiere Fallstudien, Vorschriften oder rechtliche Präzedenzfälle von offiziellen Websites

### E-Commerce & Einzelhandel

* **Dynamische Preisstrategien**: Erhalte Echtzeit-Produktpreise von konkurrierenden Geschäften
* **Produktinformationsmanagement**: Extrahiere detaillierte Spezifikationen und Beschreibungen
* **Lager-/Inventarüberwachung**: Überprüfe die Produktverfügbarkeit bei anderen Einzelhändlern
* **Rezensionsanalyse**: Sammle Kundenfeedback und -stimmung für spezifische Produkte

### Marketing & Inhaltserstellung

* **Inhaltskuratierung**: Extrahiere relevante Artikel und Blogposts für Newsletter
* **SEO-Analyse**: Untersuche die Keyword-Nutzung, Meta-Beschreibungen und Seitenstruktur von Wettbewerbern
* **Lead-Generierung**: Extrahiere Kontaktinformationen aus Unternehmensverzeichnissen oder Unternehmensseiten
* **Influencer-Forschung**: Sammle Engagement-Metriken und Inhaltsstile von Influencer-Profilen
* **Personalisierte Social-Media-Generierung**: Erstelle KI-gestützte Social-Media-Marketing durch Analyse von Kundenwebsites

### Datenanwendungen

* **AI-Trainingsdatensammlung**: Sammle spezifische Beispiele für maschinelle Lernmodelle
* **Benutzerdefinierte Wissensdatenbankerstellung**: Extrahiere Dokumentationen oder Anleitungen von Softwareseiten
* **Historische Datenarchive**: Bewahre Website-Inhalte zu bestimmten Zeitpunkten
* **Strukturierte Datenextraktion**: Transformiere Webinhalte in formatierte Datensätze zur Analyse

### Überwachung & Warnungen

* **Überwachung der Einhaltung von Vorschriften**: Verfolge Änderungen an rechtlichen oder regulatorischen Websites
* **Krisenmanagement**: Überwache Nachrichtenseiten auf Erwähnungen bestimmter Ereignisse oder Organisationen
* **Ereignisverfolgung**: Extrahiere Details zu bevorstehenden Veranstaltungen von Veranstaltungsorten oder Veranstalter-Websites
* **Überwachung des Dienststatus**: Überprüfe Dienststatusseiten für spezifische Plattformen oder Tools

### Veröffentlichung & Medien

* **Nachrichtenaggregation**: Extrahiere aktuelle Nachrichten aus offiziellen Quellen
* **Medienüberwachung**: Verfolge spezifische Themen auf Nachrichtenseiten
* **Inhaltsverifizierung**: Extrahiere Informationen, um Behauptungen oder Aussagen zu überprüfen
* **Multimedia-Extraktion**: Sammle eingebettete Videos, Bilder oder Audiodateien für Medienbibliotheken

### Finanzanwendungen

* **Investitionsforschung**: Extrahiere Finanzberichte oder Jahresberichte von Unternehmenswebsites
* **Wirtschaftsindikatoren**: Sammle Wirtschaftsdaten von Regierungs- oder Finanzinstitutions-Websites
* **Kryptowährungsdaten**: Extrahiere Echtzeit-Preise und Marktkapitalisierungsinformationen
* **Finanznachrichtenanalyse**: Überwache Finanznachrichtenseiten auf spezifische Marktsignale

### Technische Anwendungen

* **API-Dokumentationsextraktion**: Sammle technische Dokumentationen zur Referenz
* **Integrationstests**: Extrahiere Website-Elemente, um Drittanbieter-Integrationen zu überprüfen
* **Barrierefreiheitstests**: Analysiere die Website-Struktur auf Einhaltung von Barrierefreiheitsstandards
* **Webarchiverstellung**: Erfasse vollständige Website-Inhalte zur historischen Bewahrung

### Integrationsszenarien

* **CRM-Systeme**: Ergänze Kundenprofile mit Daten von Unternehmenswebsites oder LinkedIn
* **Content-Management-Systeme**: Importiere relevante externe Inhalte
* **Business-Intelligence-Tools**: Ergänze interne Daten mit externen Marktinformationen
* **Projektmanagement-Software**: Extrahiere Spezifikationen oder Anforderungen von Kundenwebsites
* **Benutzerdefinierte Dashboards**: Zeige extrahierte Daten neben internen Metriken an

## Fehlerbehandlung

Alle Fehler folgen einer gemeinsamen Umschlagform. Überprüfe `error.type` und `error.code`, um programmatisch zu verzweigen:

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

| HTTP | `error.type` | `error.code` | Bedeutung |
| - | - | - | - |
| 400 | `invalid_request_error` | `dns_resolution_failed` | Die Domain existiert nicht oder die URL enthält einen Tippfehler. |
| 400 | `invalid_request_error` | `invalid_url` | Die URL ist fehlerhaft. |
| 502 | `invalid_request_error` | `tls_error` | Die Website hat ein ungültiges oder inkompatibles TLS/SSL-Zertifikat. `error.detail` enthält den Low-Level-SSL-Code. |
| 504 | `request_timeout` | `scrape_poll_timeout` | Der Scrape wurde nicht innerhalb des \~55-Sekunden-Wartebudgets abgeschlossen. |

### DNS-Fehler (400)

Die Domain wird nicht aufgelöst. Überprüfe die URL auf Tippfehler.

```json theme={null}
{
  "error": {
    "type": "invalid_request_error",
    "code": "dns_resolution_failed",
    "message": "Die URL enthält einen Tippfehler oder die Domain existiert nicht."
  }
}
```

### TLS/SSL-Fehler (502)

Die Zielwebsite hat eine fehlerhafte oder inkompatible HTTPS-Konfiguration. `error.detail` liefert den spezifischen SSL-Fehlercode zur Diagnose; `error.code` ist immer `tls_error`.

```json theme={null}
{
  "error": {
    "type": "invalid_request_error",
    "code": "tls_error",
    "detail": "err_ssl_tlsv1_alert_internal_error",
    "message": "Die Website hat den TLS-Handshake geschlossen oder abgelehnt. Der Server ist möglicherweise falsch konfiguriert oder verwendet eine nicht unterstützte SSL/TLS-Version."
  }
}
```

### Anfrage-Timeout (504)

Der Scrape wurde nicht innerhalb des Wartebudgets abgeschlossen. Die Seite kann langsam, bot-geschützt oder vorübergehend nicht verfügbar sein. Diese Antwort ist sicher erneut zu versuchen.

```json theme={null}
{
  "error": {
    "type": "request_timeout",
    "code": "scrape_poll_timeout",
    "message": "Anfragezeitüberschreitung beim Warten auf Scrape-Ergebnis. Die Seite kann langsam sein, für unsere Fetcher blockiert oder vorübergehend nicht verfügbar."
  }
}
```

## Preise

Scrape kostet standardmäßig 1 Credit. Wenn du auch [Parsers](/features/structured-content/parsers) verwendest, variieren die Kosten je nach Parser (1-5 Credits). Wenn du [LLM extract](/features/structured-content/llm-extraction) verwendest, kostet es 10 Credits.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.