Olostep Docs - Scrape Endpoint

Über den Olostep /v1/scrapes Endpoint 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 oder LLM extraction
Handhabt dynamische Inhalte: JS-gerenderte Seiten, Login-Flows über Aktionen, PDFs
Kontrolliere, wie lange Ergebnisse mit dem storage Parameter gespeichert werden

Für API-Details siehe die Scrape Endpoint API Referenz.

Eine URL scrapen

Verwende den /v1/scrapes Endpoint, um eine einzelne URL zu scrapen und Ausgabeformate auszuwählen.

Installation

pip install olostep

npm install olostep

# curl ist standardmäßig auf macOS, Linux und Windows verfügbar

npm install node-fetch

pip install requests

Verwendung

Du kannst den Endpoint verwenden, um eine einzelne URL zu scrapen und Ausgabeformate auszuwä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.

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

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

{
  "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 bereits ein passendes Scrape mit denselben Parametern existiert. Wenn ein ausreichend frisches Match gefunden wird, wird der Inhalt sofort aus dem Olostep-Speicher bereitgestellt, ohne einen neuen Browser-Scrape zu starten.

Gemeinsamer Cache: Der Cache wird global 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 Kernseitenabruf, sodass 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 Alter des Inhalts 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.
Standardverhalten im Playground: 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

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
)

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,
})

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

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)

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

Wann wird der Cache übersprungen?

Der Cache wird automatisch umgangen (und ein Live-Scrape erzwungen), 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: Erfassung von network_calls oder Verwendung von asynchronen Parser-Jobs.

Speicherung

Scrape-Ergebnisse werden standardmäßig etwa 7 Tage lang aufbewahrt. Übergebe ein storage Objekt, um ein Ergebnis länger — oder unbegrenzt — zu speichern, damit du es später erneut abrufen kannst. Das Ergebnis, seine gehosteten URLs und GET /v1/scrapes/{scrape_id} bleiben für dieses Fenster verfügbar. max_age steuert, ob eine neue Anfrage eine zwischengespeicherte Seite wiederverwenden kann. storage.expires_in steuert, wie lange das Ergebnis dieses Scrapes verfügbar bleibt. Siehe Caching für max_age. storage ist in allen Plänen für POST /v1/scrapes verfügbar.

Parameter	Typ	Standard	Beschreibung
`storage.expires_in`	`string`	etwa 7 Tage (wenn `storage` weggelassen wird)	Wie lange das Ergebnis aufbewahrt werden soll. Eines von `10d`, `30d`, `60d`, `90d`, `180d`, `365d` oder `never` (unbegrenzt).

Verwendung

from olostep import Olostep

client = Olostep(api_key="YOUR_REAL_KEY")

# Halte diesen Scrape für 90 Tage
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' })

// Halte diesen Scrape für 90 Tage
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 extrahieren

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

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

Glob-Muster stimmen mit Pfadsegmenten überein. Ein einzelnes * überschreitet nicht /, sodass "/blog/*" "/blog/post-1" entspricht, aber nicht dem Index "/blog" selbst — und es entspricht niemals "/blog?tag=x", da Abfragezeichenfolgen nicht Teil des Pfads sind. Um den Index ebenfalls einzuschließen, verwende "/blog*" oder "{/blog,/blog/**}".

Scrape-Formate

Wähle ein oder mehrere Ausgabeformate über formats:

markdown: LLM-freundliches Markdown
html: bereinigtes HTML
text: Klartext
json: strukturiertes Ergebnis (ü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.

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 hat einige vorgefertigte Parser für beliebte Websites, 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)

Stelle llm_extract mit einem JSON-Schema (schema) und/oder einer natürlichen Sprachinstruktion (prompt) bereit. 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.

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

Hinweis: Im Python SDK ist result.json_content bereits ein dict. Im Node SDK und der rohen API ist es ein JSON-String, also parse es (JSON.parse / json.loads), 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, um Zugang zu erhalten.

Links auf der Seite extrahieren

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

absolute_links (boolean, Standard: true): Wenn true, werden vollständige URLs (z. B. https://example.com/page) anstelle relativer Pfade (z. B. /page) zurückgegeben.
query_to_order_links_by (string): Sortiert die zurückgegebenen Links nach ihrer Ähnlichkeit mit dem bereitgestellten Abfragetext und priorisiert die relevantesten Übereinstimmungen zuerst.
include_links (Array von Strings): Filtere extrahierte Links mit Glob-Mustern. Verwende Muster wie *.pdf, um Dateierweiterungen abzugleichen, /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 bestimmte Links mit Glob-Mustern aus, die derselben Syntax wie include_links folgen.

Mit der Seite mit Aktionen interagieren

Führe Aktionen vor dem Scraping aus, 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

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 }
    ]
  }'

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

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

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 Endpoint verwenden.

Inhaltsanalyse & Forschung

Wettbewerbsanalyse: Extrahiere Produktdetails, Preise und Funktionen von Wettbewerber-Websites
Marktforschung: Analysiere Landingpages, Produktbeschreibungen und Kundenbewertungen
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
Bestandsüberwachung: Überprüfe die Produktverfügbarkeit bei anderen Einzelhändlern
Rezensionsanalyse: Sammle Verbraucherfeedback und Stimmungen für bestimmte 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 Firmenwebsites
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
Erstellung einer benutzerdefinierten Wissensdatenbank: Extrahiere Dokumentationen oder Anleitungen von Software-Websites
Historische Datenarchive: Bewahre Website-Inhalte zu bestimmten Zeitpunkten auf
Strukturierte Datenextraktion: Transformiere Webinhalte in formatierte Datensätze zur Analyse

Überwachung & Benachrichtigungen

Überwachung der Einhaltung von Vorschriften: Verfolge Änderungen auf rechtlichen oder regulatorischen Websites
Krisenmanagement: Überwache Nachrichtenseiten auf Erwähnungen bestimmter Ereignisse oder Organisationen
Verfolgung von Veranstaltungen: Extrahiere Details zu bevorstehenden Veranstaltungen von Veranstaltungsorten oder Organisator-Websites
Überwachung des Dienststatus: Überprüfe Statusseiten von Diensten für bestimmte Plattformen oder Tools

Verlagswesen & Medien

Nachrichtenaggregation: Extrahiere aktuelle Nachrichten aus offiziellen Quellen
Medienüberwachung: Verfolge bestimmte Themen auf Nachrichtenseiten
Inhaltsverifizierung: Extrahiere Informationen zur Überprüfung von Behauptungen oder Aussagen
Multimedia-Extraktion: Sammle eingebettete Videos, Bilder oder Audiodateien für Medienbibliotheken

Finanzanwendungen

Investmentforschung: Extrahiere Finanzberichte oder Jahresberichte von Unternehmenswebsites
Wirtschaftsindikatoren: Sammle Wirtschaftsdaten von Regierungs- oder Finanzinstitutionswebsites
Kryptowährungsdaten: Extrahiere Echtzeitpreise und Marktkapitalisierungsinformationen
Analyse von Finanznachrichten: Überwache Finanznachrichtenseiten auf spezifische Marktsignale

Technische Anwendungen

API-Dokumentationsextraktion: Sammle technische Dokumentationen zur Referenz
Integrationstests: Extrahiere Website-Elemente zur Überprüfung von Drittanbieter-Integrationen
Barrierefreiheitstests: Analysiere die Website-Struktur auf Einhaltung von Barrierefreiheitsstandards
Erstellung von Webarchiven: 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:

{
  "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.

{
  "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 für Diagnosen; error.code ist immer tls_error.

{
  "error": {
    "type": "invalid_request_error",
    "code": "tls_error",
    "detail": "err_ssl_tlsv1_alert_internal_error",
    "message": "Die Website hat die TLS-Handshake geschlossen oder abgelehnt. Der Server könnte falsch konfiguriert sein oder eine nicht unterstützte SSL/TLS-Version verwenden."
  }
}

Anfrage-Timeout (504)

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

{
  "error": {
    "type": "request_timeout",
    "code": "scrape_poll_timeout",
    "message": "Anfragezeitüberschreitung beim Warten auf das Scrape-Ergebnis. Die Seite könnte langsam, für unsere Abrufdienste blockiert oder vorübergehend nicht verfügbar sein."
  }
}

Preise

Scrape kostet standardmäßig 1 Credit. Wenn du auch parsers verwendest, variieren die Kosten je nach Parser (1-5 Credits). Wenn du LLM extract verwendest, kostet es 10 Credits.

Loslegen

Funktionen

Kontostand & Abrechnung

Scrape

Eine URL scrapen

Installation

Verwendung

Antwort

Caching

Wie es funktioniert

Frische und `max_age`

Anwendungsbeispiele

Wann wird der Cache übersprungen?

Speicherung

Verwendung

Links extrahieren

Scrape-Formate

Strukturierte Daten extrahieren

Verwendung eines Parsers (empfohlen für Skalierung)

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

Links auf der Seite extrahieren

Mit der Seite mit Aktionen interagieren

Beispiel

Anwendungsfälle

Inhaltsanalyse & Forschung

E-Commerce & Einzelhandel

Marketing & Inhaltserstellung

Datenanwendungen

Überwachung & Benachrichtigungen

Verlagswesen & Medien

Finanzanwendungen

Technische Anwendungen

Integrationsszenarien

Fehlerbehandlung

DNS-Fehler (400)

TLS/SSL-Fehler (502)

Anfrage-Timeout (504)

Preise

​Eine URL scrapen

​Installation

​Verwendung

​Antwort

​Caching

​Wie es funktioniert

​Frische und max_age

​Anwendungsbeispiele

​Wann wird der Cache übersprungen?

​Speicherung

​Verwendung

​Links extrahieren

​Scrape-Formate

​Strukturierte Daten extrahieren

​Verwendung eines Parsers (empfohlen für Skalierung)

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

​Links auf der Seite extrahieren

​Mit der Seite mit Aktionen interagieren

​Beispiel

​Anwendungsfälle

​Inhaltsanalyse & Forschung

​E-Commerce & Einzelhandel

​Marketing & Inhaltserstellung

​Datenanwendungen

​Überwachung & Benachrichtigungen

​Verlagswesen & Medien

​Finanzanwendungen

​Technische Anwendungen

​Integrationsszenarien

​Fehlerbehandlung

​DNS-Fehler (400)

​TLS/SSL-Fehler (502)

​Anfrage-Timeout (504)

​Preise

Eine URL scrapen

Installation

Verwendung

Antwort

Caching

Wie es funktioniert

Frische und `max_age`

Anwendungsbeispiele

Wann wird der Cache übersprungen?

Speicherung

Verwendung

Links extrahieren

Scrape-Formate

Strukturierte Daten extrahieren

Verwendung eines Parsers (empfohlen für Skalierung)

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

Links auf der Seite extrahieren

Mit der Seite mit Aktionen interagieren

Beispiel

Anwendungsfälle

Inhaltsanalyse & Forschung

E-Commerce & Einzelhandel

Marketing & Inhaltserstellung

Datenanwendungen

Überwachung & Benachrichtigungen

Verlagswesen & Medien

Finanzanwendungen

Technische Anwendungen

Integrationsszenarien

Fehlerbehandlung

DNS-Fehler (400)

TLS/SSL-Fehler (502)

Anfrage-Timeout (504)

Preise