OpenSea-Daten mit Python scrapenNFT-Metadaten, gerendert und geparst

OpenSea ist eines der größten NFT-Marktplätze, und jede Kollektions- und Listungsseite enthält genau die strukturierten Daten, die ein NFT-Preistracker, ein Marktforschungs-Notizbuch oder ein Seltenheits-Dashboard benötigt: einen Artikelnamen, die Kollektion, zu der er gehört, den aktuellen Listungspreis in ETH, den letzten Verkauf, die Token-ID und das Bild. Der Haken dabei ist, dass OpenSea eine JavaScript-lastige React-Anwendung ist, sodass eine einfache HTTP-Anfrage eine fast leere Shell anstelle der gesuchten Artikel zurückgibt.

Diese Anleitung zeigt Ihnen, wie Sie OpenSea-Daten mit Python scrapen können, und zwar auf zuverlässige Weise. Sie bauen einen kleinen, lauffähigen Scraper, der eine gerenderte Kollektionsseite über die Crawling API mit einem JavaScript-Token abruft, jeden Artikel mit BeautifulSoup parst und saubere strukturierte Datensätze ausgibt. Die gesamte Anleitung beschränkt sich auf öffentliche NFT-Daten, die jeder auf einer Kollektionsseite sehen kann, und der Abschnitt zur Rechtslage am Ende ist kein Boilerplate, also lesen Sie ihn, bevor Sie dies auf ein echtes Volumen anwenden.

Was Sie bauen werden

Ein Python-Skript, das eine öffentliche OpenSea-Kollektions-URL nimmt, das gerenderte HTML über die Crawling API abruft und für jedes NFT auf der Seite einen strukturierten Datensatz extrahiert. Wir verwenden eine öffentliche Kollektion als laufendes Beispiel und ziehen diese Felder aus jeder Artikelkarte heraus:

• Artikelname der eindeutige Name des einzelnen NFT, zum Beispiel "Courtyard #1024".
• Kollektion die Kollektion, zu der der Artikel gehört.
• Preis (ETH) der aktuelle Listungspreis, wie er auf der Karte angezeigt wird.
• Letzter Verkauf der Preis, zu dem der Artikel zuvor verkauft wurde, wenn die Karte ihn anzeigt.
• Token-ID die eindeutige On-Chain-Kennung, nützlich zum Verfolgen eines Tokens über Plattformen hinweg.
• Bild-URL die Quelle des Miniaturbilds des Artikels.
• Artikel-URL der Link zur individuellen NFT-Detailseite.

Warum eine einfache Anfrage bei OpenSea scheitert

Wenn Sie eine OpenSea-Kollektions-URL mit einem einfachen HTTP-Client anfordern, erhalten Sie eine Antwort mit Status 200 und fast keine NFT-Daten im Body. Zwei Dinge arbeiten gegen Sie. Erstens ist OpenSea eine clientseitige React-App, die ihr Artikelraster im Browser aufbaut, sodass das anfängliche HTML ein Rahmen ist, der sich erst füllt, nachdem die Skripte der Seite ausgeführt wurden und die Marktplatzdaten über das Netzwerk geladen wurden. Zweitens kennzeichnet OpenSea automatisierten Datenverkehr schnell: Datacenter-IPs und Anfragemuster, die nicht wie ein echter Browser aussehen, werden herausgefordert oder blockiert, bevor sie das gerenderte Raster jemals erreichen.

Ein funktionierender OpenSea-Scraper benötigt daher zwei Dinge in einer Anfrage: einen Browser, der die Seite tatsächlich rendert, und eine IP, die die Plattform als echten Besucher liest. Sie können das selbst mit einem Headless-Browser plus einem Pool rotierender residentieller Proxys zusammenstellen, aber das Zusammenführen und Gesundhalten davon ist der größte Teil der Arbeit. Die Crawling API faltet beides in einen einzigen Aufruf: Sie senden ihr die URL mit einem JavaScript-Token, sie rendert die Seite hinter einer vertrauenswürdigen IP und gibt fertiges HTML zum Parsen zurück. Wenn clientseitiges Rendering für Sie neu ist, erklärt unser Leitfaden zu JavaScript-Websites crawlen, warum Rendering wichtig ist.

Voraussetzungen

Vor dem Schreiben von Code müssen einige Dinge eingerichtet sein. Keines davon dauert lange.

Grundlegendes Python. Sie sollten damit vertraut sein, ein Python-Skript zu schreiben und auszuführen sowie Pakete mit pip zu installieren. Wenn BeautifulSoup für Sie neu ist, deckt unser Leitfaden zur Verwendung von BeautifulSoup in Python die grundlegenden Parsing-Grundlagen ab, die dieses Tutorial voraussetzt.

Python 3.8 oder höher. Bestätigen Sie Ihre Version mit python --version. Falls Sie es nicht haben, installieren Sie es von python.org oder über eine Distribution wie Anaconda.

Ein Crawlbase-Konto und JS-Token. Registrieren Sie sich, öffnen Sie Ihr Dashboard und kopieren Sie Ihr JavaScript (JS)-Token von der Konto-Docs-Seite. Behandeln Sie das Token wie ein Passwort: Es authentifiziert Ihre Anfragen, halten Sie es daher aus der Versionskontrolle heraus.

Projekt einrichten

Erstellen Sie eine virtuelle Umgebung, damit Projektabhängigkeiten isoliert bleiben, und installieren Sie dann die beiden Bibliotheken, die der Scraper benötigt.

python --version

python -m venv opensea_env
source opensea_env/bin/activate

pip install crawlbase beautifulsoup4

Aktivieren Sie unter Windows die Umgebung mit opensea_env\Scripts\activate anstelle der source-Zeile. Zwei Abhängigkeiten erledigen die Arbeit: crawlbase ist der offizielle Client für die Crawling API, und beautifulsoup4 parst das zurückgegebene HTML, sodass Sie einzelne Felder per CSS-Selektor herausziehen können.

Schritt 1: Die gerenderte Kollektionsseite abrufen

Beginnen Sie damit, die fertige Seite zu holen. Importieren Sie die Klasse CrawlingAPI, initialisieren Sie sie mit Ihrem JS-Token und fordern Sie die Kollektions-URL an. Die Statusprüfung vor dem Parsen sorgt dafür, dass Fehler laut statt still bleiben.

from crawlbase import CrawlingAPI

api = CrawlingAPI({"token": "YOUR_CRAWLBASE_JS_TOKEN"})

def crawl(page_url):
    options = {"ajax_wait": "true", "page_wait": 5000}
    response = api.get(page_url, options)
    if response["status_code"] == 200:
        return response["body"].decode("utf-8")
    print(f"Request failed: {response['status_code']}")
    return None

if __name__ == "__main__":
    page_url = "https://opensea.io/collection/courtyard-nft"
    html = crawl(page_url)
    print(html[:500] if html else "No HTML returned")

Die beiden Warteoptionen sind bei einem clientseitig gerenderten Ziel wie diesem wichtig. ajax_wait weist die API an, auf das Fertigladen asynchroner Inhalte zu warten, was OpenSea verwendet, um sein Artikelraster zu befüllen, und page_wait hält eine festgelegte Anzahl von Millisekunden nach dem Laden an, damit spät rendernde Karten erscheinen, bevor die Seite erfasst wird. Fünf Sekunden sind ein vernünftiger Ausgangspunkt; erhöhen Sie den Wert, wenn die Karten leer zurückkommen. Führen Sie das Skript mit python scraper.py aus, und Sie sollten echtes Artikel-Markup sehen, nicht den leeren Rahmen, den ein einfacher Abruf zurückgibt. Das bestätigt, dass das Rendering funktioniert, bevor Sie einen einzigen Selektor schreiben.

Schritt 2: Die Artikelkarten mit BeautifulSoup parsen

Mit gerendertem HTML laden Sie es in BeautifulSoup und ziehen jeden NFT per Selektor heraus. OpenSea legt seine Kollektion als Raster wiederholter Artikelkarten aus, also wählen Sie alle Karten einmal aus und lesen dann dieselben Felder aus jeder. Untersuchen Sie die Live-Seite in den Entwicklertools Ihres Browsers, um die aktuellen Attribute zu bestätigen; die nachstehenden Selektoren entsprechen dem Layout zum Zeitpunkt des Schreibens.

from bs4 import BeautifulSoup

BASE = "https://opensea.io"

def text_of(card, selector):
    el = card.select_one(selector)
    return el.get_text(strip=True) if el else None

def token_id_from(href):
    # OpenSea item URLs end with the token id, e.g. /assets/.../1024
    return href.rstrip("/").split("/")[-1] if href else None

def parse_collection(html):
    soup = BeautifulSoup(html, "html.parser")
    cards = soup.select('article.AssetSearchList--asset')
    items = []

    for card in cards:
        link = card.select_one("a.Asset--anchor")
        href = link["href"] if link else None
        img = card.select_one("img")
        items.append({
            "name": text_of(card, 'span[data-testid="ItemCardFooter-name"]'),
            "price_eth": text_of(card, 'div[data-testid="ItemCardPrice"] span[data-id="TextBody"]'),
            "last_sale": text_of(card, 'div[data-testid="ItemCardPrice-secondary"]'),
            "token_id": token_id_from(href),
            "image_url": img["src"] if img else None,
            "item_url": BASE + href if href else None,
        })

    return items

Der text_of-Helfer erledigt zwei nützliche Dinge gleichzeitig: Er fragt ein einzelnes Element innerhalb der Karte ab und gibt None zurück, wenn dieses Element fehlt, anstatt bei einem .get_text()-Aufruf auf nichts zu werfen. Das macht die Extraktion belastbar, wenn ein Feld bei einer bestimmten Karte fehlt, was häufig vorkommt, da nicht jedes NFT einen Letzter-Verkauf-Preis oder ein aktuelles Listing zeigt. Der Artikelname kommt aus dem data-testid="ItemCardFooter-name"-Span, der Listungspreis aus dem verschachtelten data-id="TextBody"-Span innerhalb von ItemCardPrice und der Link aus dem Asset--anchor-Anker. Die Token-ID ist das letzte Pfadsegment dieses Links, und die vollständige Artikel-URL ist der Basishost, der mit dem relativen Href verknüpft ist.

Schritt 3: Scroll-basierte Paginierung verwalten

Eine Kollektionsseite lädt nicht alle Artikel im Voraus. OpenSea verwendet unendliches Scrollen, sodass mehr NFTs erst erscheinen, wenn Sie im Raster nach unten scrollen. Anstatt die Paginierungsaufrufe rückzuentwickeln, lassen Sie die Crawling API die Seite für Sie mit den Optionen scroll und scroll_interval scrollen. Die API scrollt für die angegebene Anzahl von Sekunden, was mehr Karten in dasselbe HTML lädt, das Sie dann parsen.

def crawl_with_scroll(page_url):
    options = {
        "ajax_wait": "true",
        "scroll": "true",
        "scroll_interval": "20",  # scroll for 20 seconds, max 60
    }
    response = api.get(page_url, options)
    if response["status_code"] == 200:
        return response["body"].decode("utf-8")
    print(f"Request failed: {response['status_code']}")
    return None

Das Setzen von scroll auf true weist die API an, die gerenderte Seite zu scrollen, und scroll_interval steuert, wie lange, bis zu 60 Sekunden. Ein längeres Intervall lädt mehr Artikel, kostet aber mehr Zeit pro Anfrage, also wählen Sie einen Wert, der dazu passt, wie tief in die Kollektion Sie gehen müssen. Beachten Sie, dass Sie beim Scrollen page_wait weglassen, da das Scrollen die Seite bereits lange genug offen hält, damit neue Karten gerendert werden.

Schritt 4: Alles zusammenfügen

Verbinden Sie nun den scroll-fähigen Abruf und den Parser zu einem einzigen lauffähigen Skript. Holen Sie das gerenderte HTML, übergeben Sie es an den Parser und schreiben Sie das Ergebnis als JSON, damit Sie es später überall laden können.

import json
from crawlbase import CrawlingAPI
from bs4 import BeautifulSoup

api = CrawlingAPI({"token": "YOUR_CRAWLBASE_JS_TOKEN"})
BASE = "https://opensea.io"

def crawl(page_url):
    options = {"ajax_wait": "true", "scroll": "true", "scroll_interval": "20"}
    response = api.get(page_url, options)
    if response["status_code"] == 200:
        return response["body"].decode("utf-8")
    print(f"Request failed: {response['status_code']}")
    return None

def text_of(card, selector):
    el = card.select_one(selector)
    return el.get_text(strip=True) if el else None

def token_id_from(href):
    return href.rstrip("/").split("/")[-1] if href else None

def parse_collection(html):
    soup = BeautifulSoup(html, "html.parser")
    cards = soup.select('article.AssetSearchList--asset')
    items = []

    for card in cards:
        link = card.select_one("a.Asset--anchor")
        href = link["href"] if link else None
        img = card.select_one("img")
        items.append({
            "name": text_of(card, 'span[data-testid="ItemCardFooter-name"]'),
            "price_eth": text_of(card, 'div[data-testid="ItemCardPrice"] span[data-id="TextBody"]'),
            "last_sale": text_of(card, 'div[data-testid="ItemCardPrice-secondary"]'),
            "token_id": token_id_from(href),
            "image_url": img["src"] if img else None,
            "item_url": BASE + href if href else None,
        })

    return items

def main():
    page_url = "https://opensea.io/collection/courtyard-nft"
    html = crawl(page_url)
    if not html:
        return
    items = parse_collection(html)
    with open("opensea_data.json", "w") as f:
        json.dump(items, f, indent=2)
    print(f"Saved {len(items)} items")

if __name__ == "__main__":
    main()

Wie die Ausgabe aussieht

Führen Sie das vollständige Skript mit python scraper.py aus, und Sie erhalten für jedes NFT einen sauberen strukturierten Datensatz, bereit zum Schreiben in JSON, CSV oder eine Datenbank. Die Preis- und Letzter-Verkauf-Felder kommen als Zeichenketten zurück, die OpenSea anzeigt, ETH-Symbol und alles, also normalisieren Sie sie nachgelagert, wenn Sie numerische Werte benötigen.

[
  {
    "name": "Courtyard #1024",
    "price_eth": "0.018 ETH",
    "last_sale": "Last sale: 0.015 ETH",
    "token_id": "1024",
    "image_url": "https://i.seadn.io/s/raw/files/abc123.png",
    "item_url": "https://opensea.io/assets/matic/0x251be3.../1024"
  },
  {
    "name": "Courtyard #2087",
    "price_eth": "0.021 ETH",
    "last_sale": null,
    "token_id": "2087",
    "image_url": "https://i.seadn.io/s/raw/files/def456.png",
    "item_url": "https://opensea.io/assets/matic/0x251be3.../2087"
  }
]

Der zweite Datensatz hat einen null-Letzten-Verkauf, was der Helfer korrekt tut: Nicht jeder Artikel wurde zuvor verkauft, daher fehlt dieses Feld einfach, anstatt einen Absturz zu verursachen.

NFT-Detailseiten scrapen

Die Kollektionsseite bietet eine kartenbasierte Zusammenfassung, aber jedes NFT hat auch seine eigene Detailseite mit reichhaltigeren Feldern, einschließlich einer längeren Beschreibung, vollständiger Preishistorie und Seltenheitsrang, wenn die Kollektion einen veröffentlicht. Der Ansatz ist derselbe wie bei der Kollektionsseite: Rendern Sie die URL mit dem JS-Token und lesen Sie dann Felder per Selektor. Die Selektoren unterscheiden sich, da das Detail-Layout anders ist, also untersuchen Sie eine Live-Artikelseite, bevor Sie sich auf sie verlassen.

def parse_nft_detail(html, url):
    soup = BeautifulSoup(html, "html.parser")
    rank = soup.select_one('[data-testid="rarity-rank"]')
    return {
        "name": text_of(soup, "h1.item--title"),
        "collection": text_of(soup, "a.item--collection-detail"),
        "price_eth": text_of(soup, "div.Price--amount"),
        "rarity_rank": rank.get_text(strip=True) if rank else None,
        "token_id": token_id_from(url),
        "item_url": url,
    }

Dies wiederverwendet dieselben Hilfsfunktionen text_of und token_id_from aus dem Kollektions-Scraper, sodass ein Detail-Durchlauf nur ein anderer Selektorsatz über dieselbe Abruf-dann-Parse-Schleife ist. Der Artikelname kommt aus der item--title-Überschrift, der Listungspreis aus Price--amount und der Seltenheitsrang aus einer rarity-rank-Test-ID, wenn die Kollektion eine bereitstellt. Wenn eine Kollektion kein Seltenheitsranking hat, bleibt dieses Feld None, was korrekt und kein Fehler ist.

Skalieren und nicht blockiert bleiben

Eine Kollektion ist eine Demo; ein echter Job läuft über mehrere Kollektionen. Die Form bleibt gleich: Halten Sie eine Liste von Kollektions-URLs bereit, holen Sie jede über die Crawling API mit aktiviertem Scrollen, parsen Sie sie mit derselben Funktion und sammeln Sie die Zeilen. Da jede Kollektionsseite dieselbe Kartenstruktur teilt, funktioniert der Parser, den Sie bereits geschrieben haben, über alle hinweg ohne Änderungen. Auch wenn das Rendering übernommen wurde, überwacht OpenSea Datenverkehr mit Scraper-förmigen Mustern, also halten einige Gewohnheiten einen Lauf gesund, die für jedes schwere Ziel gelten.

• Verteilen Sie Ihre Anfragen. Kollektionsseiten in einer engen Schleife zu bombardieren, ist der schnellste Weg, gedrosselt zu werden. Verteilen Sie Anfragen und variieren Sie Ihre Ziele, anstatt eine Kollektion mit voller Geschwindigkeit zu crawlen.
• Setzen Sie auf Rotation. Ein Pool residentieller IPs verteilt Anfragen auf viele echte Benutzeradressen, sodass keine einzelne ein Ratenlimit auslöst. Die Crawling API kümmert sich darum; wenn Sie Ihren eigenen Stack betreiben, ist das der Teil, den Sie richtig hinbekommen müssen.
• Lesen Sie die Statuscodes. Ein Lauf, der beginnt, Herausforderungen oder Fehler zurückzugeben, teilt Ihnen mit, dass die aktuelle Rate oder IP-Ebene nicht mehr ausreicht. Behandeln Sie das als Signal zum Zurückziehen, nicht als Rauschen, das Sie ignorieren.

Das breite Playbook finden Sie unter wie man Websites scrapt, ohne blockiert zu werden. Wenn Sie Ihren eigenen Datenverkehr lieber durch einen rotierenden Pool leiten möchten, anstatt die verwaltete API zu verwenden, bietet der Smart AI Proxy (auch als AI Proxy bezeichnet) dieselbe residentielle IP-Rotation als Drop-in-Proxy-Endpunkt.

Ist es legal, OpenSea zu scrapen?

Ob das Scrapen von OpenSea erlaubt ist, hängt von den Nutzungsbedingungen von OpenSea, Ihrer Rechtsordnung und dem ab, was Sie mit den Daten tun. Die Bedingungen von OpenSea setzen Grenzen für den automatisierten Zugriff, daher kann das Scrapen gegen diese Bedingungen verstoßen, unabhängig davon, wie sorgfältig Ihr Tooling ist. Keiner der hier gezeigten Codes ändert das; er macht nur den technischen Teil funktionstüchtig. Lesen Sie die Nutzungsbedingungen von OpenSea und seine robots.txt und behandeln Sie beide als Grenze für das, was Sie sammeln.

Einige Grundsätze, an die Sie sich halten sollten. Sammeln Sie nur öffentliche NFT-Daten: den Artikelnamen, die Kollektion, den Listungspreis, den letzten Verkauf, die Token-ID, das Bild und den Link, die jeder auf einer Kollektionsseite ohne Konto sehen kann. Respektieren Sie die von OpenSea angegebenen Ratenerwartungen und halten Sie Ihr Anfragevolumen niedrig genug, dass Sie seine Server nicht belasten. Die Token-Metadaten selbst liegen on-chain, daher ist für viele Anwendungsfälle das direkte Lesen der Blockchain sowohl sauberer als auch eindeutig. Verteilen Sie keine Kunstwerke oder Medien, die mit einem NFT verbunden sind, als wären sie Ihre eigenen; die Bild-URL kann referenziert werden, die zugrundeliegenden Medien gehören dem Ersteller.

Für die Produktion oder den kommerziellen Einsatz veröffentlicht OpenSea eine offizielle API, und das ist der Weg, den es für Entwickler bei Marktplatzdaten vorsieht. Sie liefert strukturierte Listings, Ereignisse und Kollektionsstatistiken unter klaren Bedingungen, ohne Seiten zu rendern oder Selektoren zu pflegen. Das Scrapen eignet sich für explorative Forschung und einmalige Analysen öffentlicher Daten; wenn Ihr Projekt fortlaufenden, volumenmäßigen oder kommerziellen Zugriff benötigt, ist die offizielle API oder eine direkte Datenvereinbarung der richtige Weg und nicht ein ausgefeilterer Scraper.

Häufig gestellte Fragen

Warum gibt ein einfacher Abruf keine NFTs von OpenSea zurück?

Weil OpenSea eine clientseitige React-Anwendung ist, die ihr Artikelraster im Browser aufbaut. Das anfängliche HTML ist ein Rahmen, der sich erst füllt, nachdem die Skripte der Seite ausgeführt wurden und die Marktplatzdaten über das Netzwerk geladen wurden, sodass eine einfache HTTP-Anfrage Status 200 mit leerem Raster zurückgibt. Um echte Daten zu erhalten, müssen Sie die Seite zuerst rendern, was das JS-Token der Crawling API für Sie übernimmt.

Brauche ich das normale Token oder das JS-Token für OpenSea?

Das JS-Token. Das normale Token ruft statisches HTML ab, was bei OpenSea denselben leeren Rahmen liefert, den auch ein einfacher Abruf zurückgibt. Das JS-Token rendert die Seite in einem echten Browser, bevor es das HTML zurückgibt, sodass die Artikelkarten vorhanden sind, wenn BeautifulSoup sie parst.

Wie lade ich mehr als den ersten Bildschirm voller Artikel?

OpenSea lädt Artikel beim unendlichen Scrollen, also erscheinen weitere erst, wenn Sie im Raster nach unten scrollen. Übergeben Sie scroll auf true gesetzt und ein scroll_interval in Sekunden an die Crawling API, und sie scrollt die gerenderte Seite für Sie, bevor sie das HTML erfasst, sodass beim Parsen mehr Karten vorhanden sind. Ein längeres Intervall lädt mehr Artikel auf Kosten einer langsameren Anfrage.

Meine Selektoren geben für jede Karte None zurück. Was hat sich geändert?

Höchstwahrscheinlich das Markup von OpenSea. Seine Klassennamen und data-testid-Attribute ändern sich ohne Ankündigung, sodass Selektoren, die letzten Monat funktioniert haben, brechen können. Untersuchen Sie einen Live-Artikel in den Entwicklertools Ihres Browsers und aktualisieren Sie die Selektoren. Regelmäßige Selektor-Wartung ist bei jedem Produktionsscraper normal.

Sollte ich OpenSea scrapen oder seine offizielle API verwenden?

Für explorative Forschung und einmalige Analysen öffentlicher Daten ist das Scrapen einer Kollektionsseite in Ordnung und deckt diese Anleitung ab. Für den Produktions-, kommerziellen oder volumenmäßigen Einsatz bevorzugen Sie die offizielle API von OpenSea: Sie gibt strukturierte Listings, Ereignisse und Kollektionsstatistiken unter klaren Bedingungen zurück, ohne Seiten zu rendern oder Selektoränderungen zu verfolgen.

Kann ich Konto- oder persönliche Daten von OpenSea scrapen?

Nein, und diese Anleitung deckt das nicht ab. Wallet-Kontodetails, alles hinter einem Login und die Kunstwerke oder Medien, die Sie weiterverteilen würden, liegen alle außerhalb öffentlicher NFT-Daten und sind daher hier nicht im Umfang enthalten und verstoßen gegen die Bedingungen von OpenSea. Beschränken Sie sich auf die öffentlichen Artikel-, Kollektions- und Listing-Daten, die jeder sehen kann, und lesen Sie die Blockchain direkt, wenn Sie autoritative Token-Metadaten benötigen.

HR

Hassan Rehan

Softwareentwickler · Crawlbase

Softwareentwickler bei Crawlbase, der praxisnahe Anleitungen zu rotierenden Proxys, Scraping und den praktischen Details schreibt, Proxys in echten Code einzubinden.