Olostep Docs - Scrape endpoint

Grâce à l’endpoint Olostep /v1/scrapes, tu peux extraire du Markdown, HTML, texte, captures d’écran ou JSON structuré compatible LLM à partir de n’importe quelle URL en temps réel.

Produit du markdown propre, des données structurées, des captures d’écran ou du html
Extrait du JSON via Parsers ou extraction LLM
Gère le contenu dynamique : sites rendus en js, flux de connexion via des actions, PDFs
Contrôle la durée de rétention des résultats avec le paramètre storage

Pour les détails de l’API, consulte la Référence API de l’endpoint Scrape.

Scraper une URL

Utilise l’endpoint /v1/scrapes pour scraper une seule URL et choisir les formats de sortie.

Installation

pip install olostep

npm install olostep

# curl est disponible par défaut sur macOS, Linux, et Windows

npm install node-fetch

pip install requests

Utilisation

Tu peux utiliser l’endpoint pour scraper une seule URL et choisir les formats de sortie. Les paramètres obligatoires sont url_to_scrape et formats. D’autres paramètres courants sont wait_before_scraping (en millisecondes), remove_css_selectors (par défaut, aucun, ou un tableau de sélecteurs), et 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))

Réponse

L’API renvoie un objet scrape en réponse. Le scrape possède quelques propriétés comme id et result. L’objet result a les champs suivants (selon le paramètre formats, certains peuvent être nuls) :

html_content : le contenu HTML de la page. Passe formats: ["html"] pour obtenir cela.
markdown_content : le contenu MD de la page. Passe formats: ["markdown"] pour obtenir cela.
text_content : le contenu texte de la page. Passe formats: ["text"] pour obtenir cela.
json_content : le contenu JSON de la page. Passe formats: ["json"] pour obtenir cela et fournis également un paramètre parser ou llm_extract.
screenshot_hosted_url : l’URL hébergée de la capture d’écran.
html_hosted_url : l’URL hébergée du contenu HTML
markdown_hosted_url : l’URL hébergée du contenu Markdown
json_hosted_url : l’URL hébergée du contenu JSON
text_hosted_url : l’URL hébergée du contenu texte
links_on_page : les liens sur la page
page_metadata : les métadonnées de la page

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

Mise en cache

Pour optimiser la vitesse, Olostep offre une couche de mise en cache partagée optionnelle pour les résultats HTML, Markdown, texte et JSON analysés.

Comment ça fonctionne

Lorsqu’un scrape est demandé, Olostep vérifie si un scrape correspondant existe déjà avec les mêmes paramètres. Si une correspondance suffisamment récente est trouvée, le contenu est servi instantanément depuis le stockage d’Olostep sans lancer un nouveau scrape de navigateur.

Cache partagé : Le cache est partagé globalement. Si une autre requête a scrappé exactement la même URL avec exactement la même configuration dans ta fenêtre de fraîcheur, tu bénéficies de l’accélération.
Post-traitement toujours en direct : Les opérations comme llm_extract et les filtres links_on_page sont exécutées à la volée sur le document mis en cache. Tu ne caches que la récupération de la page principale, gardant tes extractions structurées dynamiques.

Fraîcheur et `max_age`

Par défaut, l’API de production effectue toujours un scrape en direct pour garantir une précision en temps réel. Tu peux opter pour la mise en cache en utilisant le paramètre max_age.

Paramètre	Type	Par défaut	Description
`max_age`	`integer`	`0`	Âge acceptable du contenu en secondes. Si une copie mise en cache existe et est plus récente que `max_age` secondes, elle est servie depuis le cache.

Comportement par défaut de l’API (max_age: 0) : Chaque requête API déclenche un nouveau scrape.
Comportement par défaut du Playground : Dans le tableau de bord du playground, max_age par défaut est de 24 heures (86400 secondes).
Âge maximum : Le cache a une limite stricte de 7 jours (604800 secondes). Tout max_age demandé au-delà de cette limite reviendra à un maximum de 7 jours.

Exemples d’utilisation

from olostep import Olostep

client = Olostep(api_key="YOUR_REAL_KEY")

# Opter pour la mise en cache : Accepter les résultats vieux d'un jour maximum (86400 secondes)
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' })

// Opter pour la mise en cache : Accepter les résultats vieux d'un jour maximum (86400 secondes)
const result = await client.scrapes.create({
  url: 'https://example.com',
  formats: ['markdown'],
  maxAge: 86400,
})

# Opter pour la mise en cache : Accepter les résultats vieux d'une heure maximum (3600 secondes)
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 // Accepter les résultats vieux d'un jour maximum (86400 secondes)
}
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 # Accepter les résultats vieux d'un jour maximum (86400 secondes)
}
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))

Quand le cache est-il ignoré ?

Le cache est automatiquement contourné (forçant un scrape en direct) lorsque ta requête nécessite :

Sessions interactives : Requêtes utilisant session_id ou chargeant un context de navigateur personnalisé.
Captures d’écran : Toute requête incluant screenshot dans les formats ou définissant l’option de capture d’écran contourne le cache.
Types de fichiers spéciaux : Téléchargements de fichiers binaires ou rendu brut de PDF.
Débogage & Réseau : Capture des network_calls ou utilisation de tâches d’analyse asynchrones.

Stockage

Les résultats de scrape sont conservés environ 7 jours par défaut. Passe un objet storage pour conserver un résultat plus longtemps — ou indéfiniment — afin de pouvoir le récupérer plus tard. Le résultat, ses URL hébergées et GET /v1/scrapes/{scrape_id} restent disponibles pendant cette période. max_age contrôle si une nouvelle requête peut réutiliser une page mise en cache. storage.expires_in contrôle combien de temps le résultat de ce scrape reste disponible. Voir Mise en cache pour max_age. storage est disponible sur tous les plans pour POST /v1/scrapes.

Paramètre	Type	Par défaut	Description
`storage.expires_in`	`string`	environ 7 jours (lorsque `storage` est omis)	Durée de conservation du résultat. L’un de `10d`, `30d`, `60d`, `90d`, `180d`, `365d`, ou `never` (indéfini).

Utilisation

from olostep import Olostep

client = Olostep(api_key="YOUR_REAL_KEY")

# Conserver ce scrape pendant 90 jours
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' })

// Conserver ce scrape pendant 90 jours
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))

Extraction des liens

Passe un objet links_on_page dans la requête pour collecter les liens trouvés sur la page. Tous les liens sont retournés comme des URLs absolues.

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

include_links / exclude_links : motifs globaux comparés à chaque chemin d’URL de lien.
query_to_order_links_by : réorganise les liens retournés par pertinence par rapport à ce texte.

Les motifs globaux correspondent aux segments de chemin. Un seul * ne traverse pas /, donc "/blog/*" correspond à "/blog/post-1" mais pas à l’index "/blog" lui-même — et il ne correspond jamais à "/blog?tag=x" car les chaînes de requête ne font pas partie du chemin. Pour inclure également l’index, utilise "/blog*" ou "{/blog,/blog/**}".

Formats de Scrape

Choisis un ou plusieurs formats de sortie via formats :

markdown : markdown compatible LLM
html : HTML nettoyé
text : texte brut
json : sortie structurée (via parser ou llm_extract)
raw_pdf : octets PDF bruts extraits vers une URL hébergée
screenshot : défini via des actions pour capturer une capture d’écran et retourner une URL hébergée

Les clés de sortie sont retournées à l’intérieur de result en tant que champs *_content et un *_hosted_url également.

Extraire des données structurées

Tu peux extraire du JSON structuré de deux manières : en utilisant des Parsers ou une extraction LLM.

Utiliser un Parser (recommandé pour l’échelle)

Définis formats: ["json"] et fournis un id de parser.

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 propose quelques parsers préconstruits pour les sites populaires mais tu peux aussi créer tes propres parsers via le tableau de bord ou demander à notre équipe de le faire pour toi. Les parsers sont auto-réparateurs et se mettront à jour vers la dernière version du site web.

Utiliser l’extraction LLM (schéma et/ou prompt)

Fournis llm_extract avec un schéma JSON (schema) et/ou une instruction en langage naturel (prompt). Tu peux passer les deux paramètres, mais si les deux sont fournis, schema a la priorité. Sinon, si tu passes juste un prompt, le LLM extraira les données en fonction du prompt et décidera lui-même de la structure des données.

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

Note : dans le SDK Python, result.json_content est déjà un dict. Dans le SDK Node et l’API brute, c’est une chaîne JSON, donc analyse-la (JSON.parse / json.loads) si tu as besoin d’un objet. Tarification : llm_extract coûte 10 crédits par scrape. Pour réduire le coût, tu peux apporter tes propres clés API ou activer la tarification basée sur l’utilisation. Contacte info@olostep.com pour obtenir l’accès.

Extraire les liens sur la page

Avec l’option links_on_page, tu peux extraire tous les liens présents sur la page que tu scrapes. Elle accepte les paramètres suivants pour aider à filtrer et ordonner les liens extraits :

absolute_links (booléen, par défaut : true) : Lorsqu’il est vrai, il renvoie des URLs complètes (par exemple, https://example.com/page) au lieu de chemins relatifs (par exemple, /page).
query_to_order_links_by (chaîne) : Ordonne les liens retournés par leur similarité avec le texte de requête fourni, en priorisant les correspondances les plus pertinentes en premier.
include_links (tableau de chaînes) : Filtre les liens extraits en utilisant des motifs globaux. Utilise des motifs comme *.pdf pour correspondre aux extensions de fichiers, /blog/* pour des chemins spécifiques, ou des URLs complètes comme https://example.com/*. Prend en charge les jokers (*), les classes de caractères ([a-z]), et l’alternance ({pattern1,pattern2}).
exclude_links (tableau de chaînes) : Exclut des liens spécifiques en utilisant des motifs globaux, suivant la même syntaxe que include_links.

Interagir avec la page avec des Actions

Effectue des actions avant de scraper pour interagir avec des sites dynamiques. Actions prises en charge :

wait avec milliseconds
click avec selector
fill_input avec selector et value
scroll avec direction et amount

Il est souvent utile d’utiliser wait avant/après d’autres actions pour permettre le chargement de la page.

Exemple

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

# Pour des options complexes comme les actions, utilise --payload-file avec un fichier JSON
olostep scrape "https://example.com/login" \
  --formats markdown \
  --payload-file actions.json

# Où actions.json contient :
# {
#   "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))

La réponse inclura tous les formats demandés (par exemple, markdown_content).

Cas d’utilisation

Voici quelques applications pratiques de clients utilisant l’endpoint /scrapes.

Analyse de contenu & Recherche

Analyse concurrentielle : Extraire les détails des produits, les prix et les caractéristiques des sites concurrents
Étude de marché : Analyser les pages de destination, les descriptions de produits et les témoignages de clients
Recherche académique : Rassembler des données spécifiques à partir de publications scientifiques ou de portails de recherche
Documentation légale : Extraire des études de cas, des réglementations ou des précédents juridiques à partir de sites officiels

E-commerce & Vente au détail

Stratégies de tarification dynamique : Obtenir les prix des produits en temps réel des magasins concurrents
Gestion de l’information produit : Extraire des spécifications détaillées et des descriptions
Surveillance des stocks/inventaires : Vérifier la disponibilité des produits chez d’autres détaillants
Analyse des avis : Recueillir les retours des consommateurs et le sentiment pour des produits spécifiques

Marketing & Création de contenu

Curation de contenu : Extraire des articles et des billets de blog pertinents pour des newsletters
Analyse SEO : Examiner l’utilisation des mots-clés, les descriptions méta et la structure des pages des concurrents
Génération de leads : Extraire des informations de contact à partir d’annuaires d’entreprises ou de pages de sociétés
Recherche d’influenceurs : Recueillir des métriques d’engagement et des styles de contenu à partir de profils d’influenceurs
Génération de médias sociaux personnalisés : Créer un marketing sur les réseaux sociaux alimenté par l’IA en analysant les sites web des clients

Applications de données

Collecte de données d’entraînement AI : Rassembler des exemples spécifiques pour les modèles d’apprentissage automatique
Création de base de connaissances personnalisée : Extraire de la documentation ou des instructions à partir de sites logiciels
Archives de données historiques : Préserver le contenu des sites web à des moments spécifiques
Extraction de données structurées : Transformer le contenu web en ensembles de données formatés pour l’analyse

Surveillance & Alertes

Surveillance de la conformité réglementaire : Suivre les changements sur les sites légaux ou réglementaires
Gestion de crise : Surveiller les sites d’actualités pour les mentions d’événements ou d’organisations spécifiques
Suivi d’événements : Extraire des détails sur les événements à venir à partir de sites de lieux ou d’organisateurs
Surveillance de l’état des services : Vérifier les pages d’état des services pour des plateformes ou outils spécifiques

Publication & Médias

Agrégation de nouvelles : Extraire les dernières nouvelles à partir de sources officielles
Surveillance des médias : Suivre des sujets spécifiques sur les sites d’actualités
Vérification de contenu : Extraire des informations pour vérifier des affirmations ou déclarations
Extraction multimédia : Rassembler des vidéos, images ou audios intégrés pour des bibliothèques de médias

Applications financières

Recherche d’investissement : Extraire des états financiers ou des rapports annuels à partir de sites d’entreprises
Indicateurs économiques : Recueillir des données économiques à partir de sites gouvernementaux ou d’institutions financières
Données sur les cryptomonnaies : Extraire des informations en temps réel sur les prix et la capitalisation boursière
Analyse des nouvelles financières : Surveiller les sites d’actualités financières pour des signaux de marché spécifiques

Applications techniques

Extraction de documentation API : Rassembler de la documentation technique pour référence
Test d’intégration : Extraire des éléments de site web pour vérifier les intégrations tierces
Test d’accessibilité : Analyser la structure du site web pour la conformité aux normes d’accessibilité
Création d’archives web : Capturer le contenu complet du site web pour une préservation historique

Scénarios d’intégration

Systèmes CRM : Améliorer les profils clients avec des données de sites d’entreprises ou Linkedin
Systèmes de gestion de contenu : Importer du contenu externe pertinent
Outils de Business Intelligence : Compléter les données internes avec des informations de marché externes
Logiciel de gestion de projet : Extraire des spécifications ou des exigences à partir de sites de clients
Tableaux de bord personnalisés : Afficher les données extraites aux côtés des métriques internes

Gestion des erreurs

Toutes les erreurs suivent une forme d’enveloppe partagée. Vérifie error.type et error.code pour te brancher de manière programmatique :

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

HTTP	`error.type`	`error.code`	Signification
400	`invalid_request_error`	`dns_resolution_failed`	Le domaine n’existe pas ou l’URL contient une faute de frappe.
400	`invalid_request_error`	`invalid_url`	L’URL est mal formée.
502	`invalid_request_error`	`tls_error`	Le site web a un certificat TLS/SSL invalide ou incompatible. `error.detail` contient le code SSL bas niveau.
504	`request_timeout`	`scrape_poll_timeout`	Le scrape n’a pas terminé dans le délai d’attente d’environ 55 secondes.

Échec DNS (400)

Le domaine ne se résout pas. Vérifie l’URL pour des fautes de frappe.

{
  "error": {
    "type": "invalid_request_error",
    "code": "dns_resolution_failed",
    "message": "L'URL contient une faute de frappe, ou le domaine n'existe pas."
  }
}

Erreur TLS/SSL (502)

Le site web cible a une configuration HTTPS cassée ou incompatible. error.detail fournit le code d’erreur SSL spécifique pour le diagnostic ; error.code est toujours tls_error.

{
  "error": {
    "type": "invalid_request_error",
    "code": "tls_error",
    "detail": "err_ssl_tlsv1_alert_internal_error",
    "message": "Le site web a fermé ou rejeté la poignée de main TLS. Le serveur peut être mal configuré ou utiliser une version SSL/TLS non prise en charge."
  }
}

Délai d’attente de la requête (504)

Le scrape n’a pas été complété dans le délai d’attente. La page peut être lente, protégée contre les robots, ou temporairement indisponible. Cette réponse est sûre à réessayer.

{
  "error": {
    "type": "request_timeout",
    "code": "scrape_poll_timeout",
    "message": "Délai d'attente dépassé lors de l'attente du résultat du scrape. La page peut être lente, bloquée pour nos fetchers, ou temporairement indisponible."
  }
}

Tarification

Scrape coûte 1 crédit par défaut. Si tu passes également des parsers, les coûts varient selon le parser (1-5 crédits). Si tu utilises LLM extract, cela coûte 10 crédits.

Commencer

Fonctionnalités

Solde et Facturation

Scrape

Scraper une URL

Installation

Utilisation

Réponse

Mise en cache

Comment ça fonctionne

Fraîcheur et `max_age`

Exemples d’utilisation

Quand le cache est-il ignoré ?

Stockage

Utilisation

Extraction des liens

Formats de Scrape

Extraire des données structurées

Utiliser un Parser (recommandé pour l’échelle)

Utiliser l’extraction LLM (schéma et/ou prompt)

Extraire les liens sur la page

Interagir avec la page avec des Actions

Exemple

Cas d’utilisation

Analyse de contenu & Recherche

E-commerce & Vente au détail

Marketing & Création de contenu

Applications de données

Surveillance & Alertes

Publication & Médias

Applications financières

Applications techniques

Scénarios d’intégration

Gestion des erreurs

Échec DNS (400)

Erreur TLS/SSL (502)

Délai d’attente de la requête (504)

Tarification

​Scraper une URL

​Installation

​Utilisation

​Réponse

​Mise en cache

​Comment ça fonctionne

​Fraîcheur et max_age

​Exemples d’utilisation

​Quand le cache est-il ignoré ?

​Stockage

​Utilisation

​Extraction des liens

​Formats de Scrape

​Extraire des données structurées

​Utiliser un Parser (recommandé pour l’échelle)

​Utiliser l’extraction LLM (schéma et/ou prompt)

​Extraire les liens sur la page

​Interagir avec la page avec des Actions

​Exemple

​Cas d’utilisation

​Analyse de contenu & Recherche

​E-commerce & Vente au détail

​Marketing & Création de contenu

​Applications de données

​Surveillance & Alertes

​Publication & Médias

​Applications financières

​Applications techniques

​Scénarios d’intégration

​Gestion des erreurs

​Échec DNS (400)

​Erreur TLS/SSL (502)

​Délai d’attente de la requête (504)

​Tarification

Scraper une URL

Installation

Utilisation

Réponse

Mise en cache

Comment ça fonctionne

Fraîcheur et `max_age`

Exemples d’utilisation

Quand le cache est-il ignoré ?

Stockage

Utilisation

Extraction des liens

Formats de Scrape

Extraire des données structurées

Utiliser un Parser (recommandé pour l’échelle)

Utiliser l’extraction LLM (schéma et/ou prompt)

Extraire les liens sur la page

Interagir avec la page avec des Actions

Exemple

Cas d’utilisation

Analyse de contenu & Recherche

E-commerce & Vente au détail

Marketing & Création de contenu

Applications de données

Surveillance & Alertes

Publication & Médias

Applications financières

Applications techniques

Scénarios d’intégration

Gestion des erreurs

Échec DNS (400)

Erreur TLS/SSL (502)

Délai d’attente de la requête (504)

Tarification