Olostep Docs - Scrape-Endpunkt

Ü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 oder LLM-Extraktion
Handhabt dynamische Inhalte: JS-gerenderte Seiten, Login-Flows über Aktionen, PDFs

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

Eine URL scrapen

Nutze den /v1/scrapes Endpunkt, um eine einzelne URL zu scrapen und Ausgabeformate zu wä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 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.

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

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

"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 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/**}".

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.

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)

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.

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)

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)

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": {
      "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: 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, 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

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

{
  "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 zur Diagnose; 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 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.

{
  "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 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 umgangen?

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 interagieren mit Aktionen

Beispiel

Anwendungsfälle

Inhaltsanalyse & Forschung

E-Commerce & Einzelhandel

Marketing & Inhaltserstellung

Datenanwendungen

Überwachung & Warnungen

Veröffentlichung & 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 umgangen?

​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 interagieren mit Aktionen

​Beispiel

​Anwendungsfälle

​Inhaltsanalyse & Forschung

​E-Commerce & Einzelhandel

​Marketing & Inhaltserstellung

​Datenanwendungen

​Überwachung & Warnungen

​Veröffentlichung & 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 umgangen?

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 interagieren mit Aktionen

Beispiel

Anwendungsfälle

Inhaltsanalyse & Forschung

E-Commerce & Einzelhandel

Marketing & Inhaltserstellung

Datenanwendungen

Überwachung & Warnungen

Veröffentlichung & Medien

Finanzanwendungen

Technische Anwendungen

Integrationsszenarien

Fehlerbehandlung

DNS-Fehler (400)

TLS/SSL-Fehler (502)

Anfrage-Timeout (504)

Preise