Das Scraping von Daten von OpenSea ist äußerst nützlich, insbesondere wenn Sie sich für NFTs (Non-Fungible Tokens) interessieren, die in den letzten Jahren einen regelrechten Boom erlebt haben. NFTs sind einzigartige digitale Assets – Kunst, Sammlerstücke, virtuelle Güter –, die durch Blockchain-Technologie gesichert sind. Als einer der größten NFT-Marktplätze verfügt OpenSea über Millionen von NFTs in allen Kategorien und ist daher für Sammler, Investoren und Entwickler eine beliebte Anlaufstelle. Egal, ob Sie Trends, Preise oder bestimmte Sammlungen verfolgen, diese Daten sind Gold wert.

OpenSea verwendet jedoch JavaScript, um die meisten seiner Daten zu laden, sodass herkömmliches Scraping nicht funktioniert. Hier kommt die Crawlbase ins Spiel. Crawling API kommt ins Spiel – es kann JavaScript-lastige Seiten verarbeiten und ist daher die perfekte Lösung zum Scraping von OpenSea-Daten.

In diesem Beitrag zeigen wir Ihnen, wie Sie OpenSea-Daten, Sammlungsseiten und einzelne NFT-Detailseiten mit Python und dem Crawlbase Crawling API. Lass uns anfangen!

Hier ist ein kurzes, ausführliches Tutorial zum Scrapen von NFT-Daten auf der Opensea-Website:

Inhaltsverzeichnis

  1. Warum OpenSea nach NFT-Daten durchsuchen?
  2. Welche Daten können Sie aus OpenSea extrahieren?
  3. OpenSea Scraping mit Crawlbase Crawling API
  4. Einrichten Ihrer Python-Umgebung
  • Installieren von Python und erforderlichen Bibliotheken
  • Auswahl einer IDE
  1. Scraping von OpenSea-Sammlungsseiten
  • Untersuchen des HTML auf CSS-Selektoren
  • Schreiben des Collection Page Scrapers
  • Handhabung der Seitennummerierung in Sammlungsseiten
  • Speichern von Daten in einer CSV-Datei
  • Vollständiges Codebeispiel
  1. Scraping von OpenSea NFT-Detailseiten
  • Untersuchen des HTML auf CSS-Selektoren
  • Schreiben des NFT-Detailseite-Scrapers
  • Speichern von Daten in einer CSV-Datei
  • Vollständiges Codebeispiel
  1. Abschließende Überlegungen
  2. Häufig gestellte Fragen

Warum OpenSea nach NFT-Daten durchsuchen?

Das Scraping von OpenSea kann Ihnen dabei helfen, wertvolle NFT-Daten, einschließlich Preise, Handelsvolumen und Eigentumsinformationen, zu verfolgen und zu analysieren. Egal, ob Sie ein NFT-Sammler, ein Entwickler, der NFT-bezogene Tools erstellt, oder ein Investor sind, der Markttrends verstehen möchte, das Extrahieren von Daten aus OpenSea liefert Ihnen die Erkenntnisse, die Sie für fundierte Entscheidungen benötigen.

Hier sind einige Gründe, warum das Scraping von OpenSea wichtig ist:

Ein Bild mit den Gründen für das Scraping von OpenSea nach NFT-Daten
  1. NFT-Preise verfolgen: Überwachen Sie einzelne NFT-Preise oder eine ganze Sammlung im Laufe der Zeit
  2. Handelsvolumen analysieren: Verstehen Sie, wie gefragt bestimmte NFTs basierend auf Verkaufs- und Handelsvolumen sind.
  3. Trends entdecken: Finden Sie in Echtzeit heraus, welche die angesagtesten NFT-Sammlungen und -Token sind.
  4. NFT-Besitzer überwachen: Scrapen Sie Eigentumsdaten, um zu sehen, wem bestimmte NFTs gehören oder wie viele Token ein Wallet besitzt.
  5. Automatisieren Sie die Datenerfassung: Anstatt OpenSea manuell zu überprüfen, können Sie die Daten automatisch erfassen und in verschiedenen Formaten wie CSV oder JSON speichern.

Die Website von OpenSea verwendet JavaScript-Rendering, daher kann das Scraping schwierig sein. Aber mit der Crawlbase Crawling API, können Sie dieses Problem beheben und die Daten problemlos extrahieren.

Welche Daten können Sie aus OpenSea extrahieren?

Beim Scraping von OpenSea ist es wichtig zu wissen, auf welche Daten man sich konzentrieren muss. Die Plattform verfügt über eine Menge Informationen über NFTs (Non-Fungible Tokens) und das Extrahieren der richtigen Daten hilft Ihnen dabei, die Leistung zu verfolgen, Trends zu analysieren und Entscheidungen zu treffen. Folgendes sollten Sie extrahieren:

Bild der wichtigsten Datenpunkte zum Extrahieren aus OpenSea
  1. NFT-Name: Der für jedes NFT einzigartige Name enthält oft ein Marken- oder Sammlungsgefühl.
  2. Sammlungsname: Die NFT-Sammlung, zu der das einzelne NFT gehört. Sammlungen stellen normalerweise Sets oder Serien von NFTs dar.
  3. Preis: Der NFT-Listenpreis. Dies ist wichtig, um Markttrends zu verstehen und den Wert von NFTs zu bestimmen.
  4. Letzter Verkaufspreis: Der Preis, zu dem das NFT zuvor verkauft wurde. Es gibt einen Überblick über die Entwicklung des NFT-Marktes.
  5. Eigentümer: Der aktuelle Inhaber des NFT (normalerweise eine Wallet-Adresse).
  6. Gründer: Der Künstler oder Ersteller des NFT. Informationen zum Ersteller sind wichtig, um Herkunft und Originalität zu verfolgen.
  7. Anzahl der Eigentümer: Einige NFTs haben mehrere Eigentümer, was darauf hinweist, wie weit verbreitet das Token ist.
  8. Seltenheit/Attribute: Viele NFTs haben Eigenschaften, die sie einzigartig und begehrenswerter machen.
  9. Handelsvolumen: Das Gesamtvolumen der Verkäufe und Übertragungen des NFT oder der gesamten Sammlung.
  10. Token-ID: Die eindeutige Kennung für das NFT in der Blockchain, nützlich für die plattformübergreifende Verfolgung bestimmter Token.

OpenSea Scraping mit Crawlbase Crawling API

Die Crawlbase Crawling API macht das Scraping von OpenSea-Daten einfach. Da OpenSea JavaScript zum Laden seiner Inhalte verwendet, schlagen herkömmliche Scraping-Methoden fehl. Die Crawlbase-API funktioniert jedoch wie ein echter Browser, sodass Sie alle benötigten Daten abrufen können.

Warum Crawlbase verwenden? Crawling API für OpenSea

  1. Verarbeitet dynamische Inhalte: Die Crawlbase Crawling API kann Seiten mit hohem JavaScript-Aufkommen verarbeiten und stellt sicher, dass das Scraping erst erfolgt, nachdem alle NFT-Daten (Preise, Eigentumsverhältnisse) offengelegt wurden.
  2. IP-Rotation: Um zu verhindern, dass Sie durch die Sicherheit von OpenSea blockiert werden, rotiert Crawlbase die IP-Adressen. So können Sie mehrere Seiten durchsuchen, ohne sich um Ratenbegrenzungen oder Sperren sorgen zu müssen.
  3. Schnelle Leistungs: Crawlbase ist schnell und effizient beim Scraping großer Datenmengen und spart Ihnen Zeit, insbesondere wenn Sie viele NFTs und Sammlungen haben.
  4. Anpassbare Anfragen: Sie können Header, Cookies und andere Parameter an Ihre Scraping-Anforderungen anpassen und die gewünschten Daten erhalten.
  5. Scrollbasierte Paginierung: Crawlbase unterstützt scrollbasierte Paginierung, sodass Sie mehr Elemente auf Sammlungsseiten erhalten, ohne manuell durch jede Seite klicken zu müssen.

Crawlbase Python-Bibliothek

Crawlbase hat auch eine Python-Bibliothek Damit können Sie Crawlbase-Produkte ganz einfach in Ihren Projekten verwenden. Sie benötigen einen Zugriffstoken, den Sie durch die Anmeldung bei Crawlbase erhalten.

Hier ist ein Beispiel zum Senden einer Anfrage an Crawlbase Crawling API:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
für Crawlbase importieren CrawlingAPI

# Initialisieren Sie die Crawlbase-API mit Ihrem Zugriffstoken
crawling_api = CrawlingAPI({'Zeichen': 'CRAWLBASE_JS_TOKEN'})

def Crawlbase-Anfrage erstellen(URL):
    Antwort = crawling_api.get(URL)

    if Antwort['Kopfzeilen']['pc_status'] == '200':
        html_content = Antwort['Körper'].dekodieren('utf-8')
        Rückkehr HTML-Inhalt
    sonst:
        drucken(f"Seite konnte nicht abgerufen werden. Crawlbase-Statuscode: {Antwort['Kopfzeilen']['pc_status']}")
        Rückkehr Keine

Note: Crawlbase bietet zwei Arten von Token: ein normales Token für statische Websites und ein JavaScript (JS)-Token für dynamische oder im Browser gerenderte Inhalte, das zum Scraping von OpenSea erforderlich ist. Crawlbase bietet außerdem 1,000 kostenlose Anfragen, um Ihnen den Einstieg zu erleichtern, und Sie können sich ohne Kreditkarte anmelden. Weitere Einzelheiten finden Sie unter Crawlbase Crawling API Dokumentation.

Im nächsten Abschnitt richten wir Ihre Python-Umgebung für das effektive Scraping von OpenSea ein.

Einrichten Ihrer Python-Umgebung

Bevor Sie Daten von OpenSea scrapen, müssen Sie Ihre Python-Umgebung einrichten. Diese Einrichtung stellt sicher, dass Sie über alle erforderlichen Tools und Bibliotheken verfügen, um Ihren Scraping-Prozess reibungslos und effizient zu gestalten. So geht's:

Installieren von Python und erforderlichen Bibliotheken

Installieren Sie Python: Laden Sie Python herunter von offiziellen Website und folgen Sie den Installationsanweisungen. Aktivieren Sie während der Installation unbedingt „Python zu PATH hinzufügen“.

Richten Sie eine virtuelle Umgebung ein (optional, aber empfohlen): So bleibt Ihr Projekt organisiert. Führen Sie diese Befehle in Ihrem Terminal aus:

1
2
3
4
5
cd Ihr_Projektverzeichnis
python -m venv venv
venv\Scripts\aktivieren  # Windows
# oder
Quelle venv/bin/aktivieren  # macOS/Linux

Erforderliche Bibliotheken installieren: Führen Sie den folgenden Befehl aus, um die erforderlichen Bibliotheken zu installieren:

1
pip installieren beautifulsoap4 crawlbase pandas
  • schöne Seife4: Zum Parsen und Extrahieren von Daten aus HTML.
  • Crawlbase: Zur Nutzung der Crawlbase Crawling API.
  • Pandas: Zur Handhabung und Speicherung von Daten im CSV-Format.

Auswahl einer IDE

Wählen Sie eine integrierte Entwicklungsumgebung (IDE) zum Schreiben Ihres Codes. Beliebte Optionen sind:

Nachdem Ihre Python-Umgebung nun eingerichtet ist, können Sie mit dem Scraping der OpenSea-Sammlungsseiten beginnen. Im nächsten Abschnitt werden wir das HTML auf CSS-Selektoren untersuchen.

Scraping von OpenSea-Sammlungsseiten

In diesem Abschnitt werden wir Sammlungsseiten von OpenSea scrapen. Sammlungsseiten zeigen verschiedene NFTs, die unter bestimmten Kategorien oder Themen gruppiert sind. Um dies effizient zu tun, werden wir die folgenden Schritte durchführen:

Untersuchen des HTML auf CSS-Selektoren

Bevor wir unseren Scraper schreiben, müssen wir die Struktur des HTML auf den OpenSea-Sammlungsseiten verstehen. So finden Sie die CSS-Selektoren:

  1. Öffnen Sie die Sammlungsseite: Gehen Sie zur OpenSea-Website und navigieren Sie zu einer beliebigen Sammlungsseite.
  2. Überprüfen Sie die Seite: Klicken Sie mit der rechten Maustaste auf die Seite und wählen Sie „Untersuchen“ oder drücken Sie Ctrl + Shift + I um die Entwicklertools zu öffnen.
HTML-Prüfung der OpenSea-Sammlungsseite
  1. Relevante Elemente finden: Suchen Sie nach den Elementen, die die NFT-Details enthalten. Häufige Datenpunkte sind:
  • Titel : In einem <span> mit data-testid="ItemCardFooter-name".
  • Preis: Befindet sich in einem <div> mit data-testid="ItemCardPrice", und zwar in einer verschachtelten <span> mit data-id="TextBody".
  • Bild-URL: In einem (n <img> Tag mit der Bildquelle im src Attribut.
  • Link: Der Link zur NFT-Detailseite befindet sich in einem <a> tag mit der klasse Asset--anchor.

Schreiben des Collection Page Scrapers

Jetzt haben wir die CSS-Selektoren und können unseren Scraper schreiben. Wir verwenden die Crawlbase Crawling API zur Handhabung der JavaScript-Darstellung mithilfe seiner ajax_wait und page_wait Parameter. Unten sehen Sie die Implementierung des Scrapers:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
für Crawlbase importieren CrawlingAPI
importieren Pandas as pd

# Initialisieren Sie die Crawlbase-API mit Ihrem Zugriffstoken
crawling_api = CrawlingAPI({'Zeichen': 'CRAWLBASE_JS_TOKEN'})

def Crawlbase-Anfrage erstellen(URL):
    Optionen = {
        'ajax_wait': "wahr",
        'Seite_warten': '5000'
    }

    Antwort = crawling_api.get(URL, Optionen)

    if Antwort['Kopfzeilen']['pc_status'] == '200':
        html_content = Antwort['Körper'].dekodieren('utf-8')
        Rückkehr HTML-Inhalt
    sonst:
        drucken(f"Seite konnte nicht abgerufen werden. Crawlbase-Statuscode: {Antwort['Kopfzeilen']['pc_status']}")
        Rückkehr Keine

def Scrape_OpenSea_Sammlung(HTML-Inhalt):
    Suppe = Schöne Suppe (HTML-Inhalt, 'html.parser')
    Daten = []

    # Finden Sie alle NFT-Artikel in der Sammlung
    nft_items = Suppe.Auswahl(„div.Asset – geladen > Artikel.AssetSearchList – Asset“)

    
für Artikel in nft_items:
        Titel = Element.Wählen Sie eins aus('span[data-testid="ItemCardFooter-name"]').text.strip() if Element.Wählen Sie eins aus('span[data-testid="ItemCardFooter-name"]') sonst ''
        Preis = Artikel.Wählen Sie einen Artikel aus('div[data-testid="ItemCardPrice"] span[data-id="TextBody"]').text.strip() if Element.Wählen Sie eins aus('div[data-testid="ItemCardPrice"] span[data-id="TextBody"]') sonst ''
        Bild = Element.Wählen Sie eins aus('img')['Quelle'] if Element.Wählen Sie eins aus('img') sonst ''
        Link = Element.Wählen Sie eins aus(„a.Asset--Anker“)['href'] if Element.Wählen Sie eins aus(„a.Asset--Anker“) sonst ''

        # Die extrahierten Daten zur Liste hinzufügen
        Daten.anhängen({
            ‚Titel‘: Titel,
            'Preis': Preis,
            'Bild-URL': Bild,
            'Link': f"https://opensea.io{Verknüpfung}"  # Erstellen Sie die vollständige URL
        })

    Rückkehr die Datenerfassung

Hier initialisieren wir die Crawlbase Crawling API und erstellen Sie eine Funktion make_crawlbase_request um die Sammlungsseite abzurufen. Die Funktion wartet, bis alle AJAX-Anfragen abgeschlossen sind, und wartet 5 Sekunden, bis die Seite vollständig gerendert ist, bevor sie das HTML an den scrape_opensea_collection Funktion.

In scrape_opensea_collection, wir analysieren das HTML mit BeautifulSoup und extrahieren Details zu jedem NFT-Element mithilfe der CSS-Selektoren, die wir zuvor definiert haben. Wir erhalten den Titel, den Preis, die Bild-URL und den Link für jedes NFT und speichern diese in einer Liste, die an den Anrufer zurückgegeben wird.

Handhabung der Seitennummerierung in Sammlungsseiten

OpenSea verwendet scrollbasierte Paginierung, sodass mehr Elemente geladen werden, wenn Sie auf der Seite nach unten scrollen. Wir können die scroll und scroll_interval Parameter dafür. Auf diese Weise müssen wir die Paginierung nicht explizit verwalten.

1
2
3
4
5
Optionen = {
    'ajax_wait': "wahr",
    'scrollen': "wahr",
    'Scrollintervall': '20'  # 20 Sekunden lang scrollen
}

Dadurch scrollt der Crawler 20 Sekunden lang, sodass wir mehr Elemente erhalten.

Speichern von Daten in einer CSV-Datei

Nachdem wir die Daten extrahiert haben, können wir sie in einer CSV-Datei speichern. Dies ist ein gängiges Format und lässt sich später leicht analysieren. So geht's:

1
2
3
4
def Daten als CSV speichern(Daten, Dateiname=„opensea_data.csv“):
    df = pd.DataFrame(Daten)
    df.to_csv(Dateiname, Index=falsch)
    drucken(f"Daten gespeichert in {Dateiname}")

Vollständiges Codebeispiel

Hier ist der vollständige Code, der alle Schritte kombiniert:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
für Crawlbase importieren CrawlingAPI
importieren Pandas as pd
für bs4 importieren BeautifulSuppe

# Initialisieren Sie die Crawlbase-API mit Ihrem Zugriffstoken
crawling_api = CrawlingAPI({'Zeichen': 'CRAWLBASE_JS_TOKEN'})

def Crawlbase-Anfrage erstellen(URL):
    Optionen = {
        'ajax_wait': "wahr",
        'scrollen': "wahr",
        'Scrollintervall': '20'  # 20 Sekunden lang scrollen
    }

    Antwort = crawling_api.get(URL, Optionen)

    if Antwort['Kopfzeilen']['pc_status'] == '200':
        html_content = Antwort['Körper'].dekodieren('utf-8')
        Rückkehr HTML-Inhalt
    sonst:
        drucken(f"Seite konnte nicht abgerufen werden. Crawlbase-Statuscode: {Antwort['Kopfzeilen']['pc_status']}")
        Rückkehr Keine

def Scrape_OpenSea_Sammlung(HTML-Inhalt):
    Suppe = Schöne Suppe (HTML-Inhalt, 'html.parser')
    Daten = []

    # Finden Sie alle NFT-Artikel in der Sammlung
    nft_items = Suppe.Auswahl(„div.Asset – geladen > Artikel.AssetSearchList – Asset“)

    
für Artikel in nft_items:
        Titel = Element.Wählen Sie eins aus('span[data-testid="ItemCardFooter-name"]').text.strip() if Element.Wählen Sie eins aus('span[data-testid="ItemCardFooter-name"]') sonst ''
        Preis = Artikel.Wählen Sie einen Artikel aus('div[data-testid="ItemCardPrice"] span[data-id="TextBody"]').text.strip() if Element.Wählen Sie eins aus('div[data-testid="ItemCardPrice"] span[data-id="TextBody"]') sonst ''
        Bild = Element.Wählen Sie eins aus('img')['Quelle'] if Element.Wählen Sie eins aus('img') sonst ''
        Link = Element.Wählen Sie eins aus(„a.Asset--Anker“)['href'] if Element.Wählen Sie eins aus(„a.Asset--Anker“) sonst ''

        # Die extrahierten Daten zur Liste hinzufügen
        Daten.anhängen({
            ‚Titel‘: Titel,
            'Preis': Preis,
            'Bild-URL': Bild,
            'Link': f"https://opensea.io{Verknüpfung}"  # Erstellen Sie die vollständige URL
        })

    Rückkehr die Datenerfassung

def Daten als CSV speichern(Daten, Dateiname=„opensea_data.csv“):
    df = pd.DataFrame(Daten)
    df.to_csv(Dateiname, Index=falsch)
    drucken(f"Daten gespeichert in {Dateiname}")

if __name__ == "__hauptsächlich__":
    URL = „https://opensea.io/collection/courtyard-nft“
    html_content = make_crawlbase_request(URL)

    if HTML-Inhalt:
        Daten = Scrape_OpenSea_Collection (HTML-Inhalt)  # Daten aus HTML-Inhalten extrahieren
        save_data_to_csv(Daten)

opensea_data.csv Schnappschuss:

Schnappschuss der Datei opensea_data.csv

Scraping von OpenSea NFT-Detailseiten

In diesem Abschnitt erfahren Sie, wie Sie NFT-Detailseiten auf OpenSea scrapen. Jedes NFT hat seine eigene Detailseite mit weiteren Informationen wie Titel, Beschreibung, Preisverlauf und anderen Details. Wir werden diese Schritte befolgen:

Untersuchen des HTML auf CSS-Selektoren

Bevor wir unseren Scraper schreiben, müssen wir die HTML-Struktur der NFT-Detailseiten finden. So geht's:

  1. Öffnen Sie eine NFT-Detailseite: Gehen Sie zu OpenSea und öffnen Sie eine beliebige NFT-Detailseite.
  2. Überprüfen Sie die Seite: Klicken Sie mit der rechten Maustaste auf die Seite und wählen Sie „Untersuchen“ oder drücken Sie Ctrl + Shift + I um die Entwicklertools zu öffnen.
HTML-Prüfung der OpenSea NFT-Detailseite
  1. Schlüsselelemente lokalisieren: Suchen Sie nach den Elementen, die die NFT-Details enthalten. Hier sind die allgemeinen Datenpunkte, nach denen Sie suchen sollten:
  • Titel : In einem (n <h1> Tag mit Klasse item--title.
  • Beschreibung: In einem <div> Tag mit Klasse item--description.
  • Preis: In einem <div> Tag mit Klasse Price--amount.
  • Bild-URL: In einem (n <img> Tag innerhalb eines <div> mit Klasse media-container.
  • Link zur NFT-Seite: Die aktuelle URL der NFT-Detailseite.

Schreiben des NFT-Detailseite-Scrapers

Jetzt, da wir unsere CSS-Selektoren haben, können wir unseren Scraper schreiben. Wir verwenden die Crawlbase Crawling API um JavaScript zu rendern. Unten sehen Sie ein Beispiel, wie Sie Daten von einer NFT-Detailseite scrapen können:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
für Crawlbase importieren CrawlingAPI
für bs4 importieren BeautifulSuppe
importieren Pandas as pd

# Initialisieren Sie die Crawlbase-API mit Ihrem Zugriffstoken
crawling_api = CrawlingAPI({'Zeichen': 'CRAWLBASE_JS_TOKEN'})

def Crawlbase-Anfrage erstellen(URL):
    Optionen = {
        'ajax_wait': "wahr",
        'Seite_warten': '5000'
    }

    Antwort = crawling_api.get(URL, Optionen)

    if Antwort['Kopfzeilen']['pc_status'] == '200':
        html_content = Antwort['Körper'].dekodieren('utf-8')
        Rückkehr HTML-Inhalt
    sonst:
        drucken(f"NFT-Detailseite konnte nicht abgerufen werden. Crawlbase-Statuscode: {Antwort['Kopfzeilen']['pc_status']}")
        Rückkehr Keine

def scrape_opensea_nft_detail(html_content, URL):
    Suppe = Schöne Suppe (HTML-Inhalt, 'html.parser')

    Titel = Suppe.select_one(„h1.item--Titel“).text.strip() if Suppe.Wähle eine(„h1.item--Titel“) sonst ''
    Beschreibung = Suppe.select_one(„div.item--Beschreibung“).text.strip() if Suppe.Wähle eine(„div.item--Beschreibung“) sonst ''
    Preis = Suppe.select_one('div.Preis--Betrag').text.strip() if Suppe.Wähle eine('div.Preis--Betrag') sonst ''
    Bild-URLs = [Bild['Quelle'] 
für img in Suppe.Auswählen(„div.media-container img“)]
    Link = URL  # Der Link ist die aktuelle URL

    nft_daten = {
        ‚Titel‘: Titel,
        'Bezeichnung': Beschreibung,
        'Preis': Preis,
        'Bilder_URL': Bild-URLs,
        'Link': Verknüpfung
    }

    Rückkehr nft_daten

Speichern von Daten in einer CSV-Datei

Sobald wir die NFT-Details gescrapt haben, können wir sie in einer CSV-Datei speichern. So können wir die Daten später problemlos analysieren. So geht's:

1
2
3
4
def speichere_NFT-Daten_in_CSV(Daten, Dateiname=„opensea_nft_data.csv“):
    df = pd.DataFrame([Daten])  # Konvertieren Sie das einzelne NFT-Datenwörterbuch in einen DataFrame
    df.to_csv(Dateiname, Index=falsch)
    drucken(f"NFT-Daten gespeichert in {Dateiname}")

Vollständiges Codebeispiel

Hier ist der vollständige Code, der alle Schritte zum Scraping von NFT-Detailseiten kombiniert:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
für Crawlbase importieren CrawlingAPI
für bs4 importieren BeautifulSuppe
importieren Pandas as pd

# Initialisieren Sie die Crawlbase-API mit Ihrem Zugriffstoken
crawling_api = CrawlingAPI({'Zeichen': 'CRAWLBASE_JS_TOKEN'})

def Crawlbase-Anfrage erstellen(URL):
    Optionen = {
        'ajax_wait': "wahr",
        'Seite_warten': '5000'
    }

    Antwort = crawling_api.get(URL, Optionen)

    if Antwort['Kopfzeilen']['pc_status'] == '200':
        html_content = Antwort['Körper'].dekodieren('utf-8')
        Rückkehr HTML-Inhalt
    sonst:
        drucken(f"NFT-Detailseite konnte nicht abgerufen werden. Crawlbase-Statuscode: {Antwort['Kopfzeilen']['pc_status']}")
        Rückkehr Keine

def scrape_opensea_nft_detail(html_content, URL):
    Suppe = Schöne Suppe (HTML-Inhalt, 'html.parser')

    Titel = Suppe.select_one(„h1.item--Titel“).text.strip() if Suppe.Wähle eine(„h1.item--Titel“) sonst ''
    Beschreibung = Suppe.select_one(„div.item--Beschreibung“).text.strip() if Suppe.Wähle eine(„div.item--Beschreibung“) sonst ''
    Preis = Suppe.select_one('div.Preis--Betrag').text.strip() if Suppe.Wähle eine('div.Preis--Betrag') sonst ''
    Bild-URLs = [Bild['Quelle'] 
für img in Suppe.Auswählen(„div.media-container img“)]
    Link = URL  # Der Link ist die aktuelle URL

    nft_daten = {
        ‚Titel‘: Titel,
        'Bezeichnung': Beschreibung,
        'Preis': Preis,
        'Bilder_URL': Bild-URLs,
        'Link': Verknüpfung
    }

    Rückkehr nft_daten

def speichere_NFT-Daten_in_CSV(Daten, Dateiname=„opensea_nft_data.csv“):
    df = pd.DataFrame([Daten])  # Konvertieren Sie das einzelne NFT-Datenwörterbuch in einen DataFrame
    df.to_csv(Dateiname, Index=falsch)
    drucken(f"NFT-Daten gespeichert in {Dateiname}")

# Beispielverwendung
if __name__ == "__hauptsächlich__":
    nft_url = "https://opensea.io/assets/matic/0x251be3a17af4892035c37ebf5890f4a4d889dcad/94953658332979117398233379364809351909803379308836092246404100025584049123386"
    html_Inhalt = make_crawlbase_request(nft_url)

    if HTML-Inhalt:
        nft_data = scrape_opensea_nft_detail(html_Inhalt, nft_URL)  # Daten aus HTML-Inhalten extrahieren
        speichere_nft_data_to_csv(nft_data)  # NFT-Daten als CSV speichern

opensea_nft_data.csv Schnappschuss:

Schnappschuss der Datei „opensea_nft_data.csv“

Optimieren Sie das OpenSea NFT-Daten-Scraping

Das Scraping von OpenSea eröffnet eine ganze Welt von NFTs und Marktdaten. In diesem Blog haben wir erläutert, wie man OpenSea mit Python scrapt und Crawlbase Crawling API. Indem Sie das Layout der Site verstehen und die richtigen Tools verwenden, können Sie wertvolle Erkenntnisse gewinnen und gleichzeitig die Ethik im Auge behalten.

Wenn Sie tiefer in Ihre Scraping-Projekte einsteigen, denken Sie daran, die Daten in für Menschen lesbaren Formaten wie CSV-Dateien zu speichern, damit die Analyse zum Kinderspiel wird. Der NFT-Bereich entwickelt sich schnell und wenn Sie über neue Trends und Technologien informiert sind, können Sie das Beste aus Ihren Datenerfassungsbemühungen herausholen. Mit der richtigen Einstellung und den richtigen Tools können Sie einige großartige Einblicke in den NFT-Markt gewinnen.

Wenn Sie mehr Web Scraping betreiben möchten, sehen Sie sich unsere Anleitungen zum Scraping anderer wichtiger Websites an.

📜 So scrapen Sie Monster.com
📜 Wie man Groupon scrapt
📜 So scrapen Sie TechCrunch
📜 Wie man Clutch.co scrapt

Wenn Sie Fragen haben oder Feedback geben möchten, unsere Support-Team kann Ihnen beim Web Scraping helfen. Viel Spaß beim Scraping!

Häufig gestellte Fragen

F: Warum sollte ich OpenSea im Web scrapen?

Web Scraping ist eine Möglichkeit, automatisch Daten von Websites zu extrahieren. Durch das Scraping von OpenSea können Sie wichtige Informationen über NFTs abrufen, z. B. deren Preise, Beschreibungen und Bilder. Diese Daten helfen Ihnen, Markttrends zu analysieren, bestimmte Sammlungen zu verfolgen oder Preise zwischen NFTs zu vergleichen. Insgesamt liefert Web Scraping wertvolle Erkenntnisse, die Ihr Verständnis des NFT-Marktes verbessern können.

Web Scraping ist eine Grauzone, wenn es um die Legalität geht. Viele Websites, darunter OpenSea, erlauben das Sammeln von Daten für den persönlichen Gebrauch, aber lesen Sie immer die Nutzungsbedingungen, bevor Sie beginnen. Stellen Sie sicher, dass Ihre Scraping-Aktivitäten den Richtlinien und Urheberrechtsgesetzen der Website entsprechen. Ethisches Scraping bedeutet, die Daten verantwortungsbewusst zu verwenden und die Server der Website nicht zu überlasten.

F: Welche Tools benötige ich, um mit dem Scraping von OpenSea zu beginnen?

Um mit dem Scraping von OpenSea zu beginnen, benötigen Sie einige Tools. Installieren Sie Python und Bibliotheken wie BeautifulSoup und Pandas zum Parsen und Bearbeiten von Daten. Sie verwenden außerdem Crawlbase Crawling API um dynamische Inhalte und JavaScript-Rendering auf OpenSea zu verarbeiten. Mit diesen Tools sind Sie bereit, NFT-Daten zu scrapen und zu analysieren.