Von der Stimmungsanalyse zum Marketing: Die vielen Vorteile von Web Scraping Twitter

Raluca Penciuc am 13. April 2023

Twitter ist eine beliebte Microblogging- und Social-Networking-Website, auf der Nutzer Nachrichten, so genannte "Tweets", veröffentlichen und mit ihnen interagieren können. Diese Tweets können eine Vielzahl von Informationen enthalten, darunter Text, Bilder und Links, was sie zu einer wertvollen Datenquelle für verschiedene Anwendungsfälle macht.

Von einzelnen Forschern bis hin zu Unternehmen kann das Web Scraping Twitter viele praktische Anwendungen bieten: Beobachtung von Trends und Nachrichten, Analyse der Verbraucherstimmung, Verbesserung von Werbekampagnen usw.

Twitter stellt zwar eine API zur Verfügung, über die Sie auf die Daten zugreifen können, aber es gibt einige Vorbehalte, die Sie beachten sollten:

Ratenbegrenzung: Sie können nur eine bestimmte Anzahl von Anfragen innerhalb eines bestimmten Zeitraums stellen. Wenn Sie diese Grenzen überschreiten, kann Ihr API-Zugang vorübergehend gesperrt werden;
Datenverfügbarkeit: Sie haben Zugriff auf eine begrenzte Anzahl von Daten, wie Tweets, Nutzerprofile und Direktnachrichten. Einige Daten, wie z. B. gelöschte Tweets, sind nicht über die API verfügbar.

In diesem Artikel wird der Prozess des Web Scraping von Twitter mit Typescript und Puppeteer besprochen. Wir befassen uns mit der Einrichtung der erforderlichen Umgebung, dem Auffinden und Extrahieren von Daten und der möglichen Verwendung dieser Daten.

Außerdem werden wir erörtern, warum die Verwendung eines professionellen Scrapers für das Web-Scraping von Twitter besser ist als die alleinige Nutzung der Twitter-API. Dieser Artikel enthält eine Schritt-für-Schritt-Anleitung zum effektiven Web-Scraping von Twitter, die es Ihnen leicht macht, die benötigten Daten zu sammeln.

Voraussetzungen

Bevor wir beginnen, sollten wir uns vergewissern, dass wir über die notwendigen Instrumente verfügen.

Laden Sie zunächst Node.js von der offiziellen Website herunter und installieren Sie es. Stellen Sie sicher, dass Sie die Long-Term Support (LTS) Version verwenden. Dadurch wird auch automatisch der Node Package Manager (NPM) installiert, den wir für die Installation weiterer Abhängigkeiten verwenden werden.

Für dieses Tutorial werden wir Visual Studio Code als integrierte Entwicklungsumgebung (IDE) verwenden, aber Sie können auch eine andere IDE Ihrer Wahl verwenden. Erstellen Sie einen neuen Ordner für Ihr Projekt, öffnen Sie das Terminal und führen Sie den folgenden Befehl aus, um ein neues Node.js-Projekt einzurichten:

npm init -y

Dadurch wird eine package.json-Datei in Ihrem Projektverzeichnis erstellt, in der Informationen über Ihr Projekt und seine Abhängigkeiten gespeichert werden.

Als nächstes müssen wir TypeScript und die Typdefinitionen für Node.js installieren. TypeScript bietet eine optionale statische Typisierung, die hilft, Fehler im Code zu vermeiden. Führen Sie dazu im Terminal aus:

npm install typescript @types/node --save-dev

Sie können die Installation überprüfen, indem Sie sie ausführen:

npx tsc --version

TypeScript verwendet eine Konfigurationsdatei namens tsconfig.json, um Compiler-Optionen und andere Einstellungen zu speichern. Um diese Datei in Ihrem Projekt zu erstellen, führen Sie den folgenden Befehl aus:

npx tsc -init

Stellen Sie sicher, dass der Wert für "outDir" auf "dist" gesetzt ist. Auf diese Weise trennen wir die TypeScript-Dateien von den kompilierten Dateien. Weitere Informationen über diese Datei und ihre Eigenschaften finden Sie in der offiziellen TypeScript-Dokumentation.

Erstellen Sie nun ein Verzeichnis "src" in Ihrem Projekt und eine neue Datei "index.ts". Hier werden wir den Scraping-Code ablegen. Um TypeScript-Code auszuführen, müssen Sie ihn zuerst kompilieren. Um sicherzustellen, dass wir diesen zusätzlichen Schritt nicht vergessen, können wir einen benutzerdefinierten Befehl verwenden.

Gehen Sie zur Datei "package. json" und bearbeiten Sie den Abschnitt "scripts" wie folgt:

"scripts": {

    "test": "npx tsc && node dist/index.js"

}

Wenn Sie das Skript ausführen wollen, müssen Sie nur "npm run test" in Ihr Terminal eingeben.

Um die Daten von der Website abzugreifen, werden wir Puppeteer verwenden, eine Headless-Browser-Bibliothek für Node.js, mit der Sie einen Webbrowser steuern und programmatisch mit Websites interagieren können. Um sie zu installieren, führen Sie diesen Befehl im Terminal aus:

npm Puppeteer installieren

Es ist sehr empfehlenswert, wenn Sie die Vollständigkeit Ihrer Daten sicherstellen wollen, da viele Websites heutzutage dynamisch generierte Inhalte enthalten. Wenn Sie neugierig geworden sind, können Sie sich die Puppeteer-Dokumentation ansehen, bevor Sie fortfahren, um zu sehen, wozu das Programm in der Lage ist.

Standort der Daten

Nachdem Sie nun Ihre Umgebung eingerichtet haben, können wir mit dem Extrahieren der Daten beginnen. Für diesen Artikel habe ich mich entschieden, das Twitter-Profil von Netflix zu scrapen: https://twitter.com/netflix.

Wir werden die folgenden Daten extrahieren:

den Profilnamen;
den Profilgriff;
die Benutzer-Bio;
den Standort des Benutzers;
die Benutzer-Website;
das Beitrittsdatum des Benutzers;
der Benutzer nach der Anzahl;
die Anzahl der Nutzer-Follower;
Informationen über die Nutzer-Tweets
- Autorenname
- Autorenhandle
- Veröffentlichungsdatum
- Textinhalt
- Medien (Videos oder Fotos)
- Anzahl der Antworten
- Anzahl der Retweets
- Anzahl der Likes
- Anzahl der Aufrufe.

Alle diese Informationen sind in der nachstehenden Abbildung hervorgehoben:

Wenn Sie die Entwicklertools für jedes dieser Elemente öffnen, können Sie die CSS-Selektoren sehen, die wir zum Auffinden der HTML-Elemente verwenden werden. Wenn Sie mit der Funktionsweise von CSS-Selektoren noch nicht vertraut sind, können Sie diesen Leitfaden für Einsteiger nutzen.

Extrahieren der Daten

Bevor wir unser Skript schreiben, sollten wir überprüfen, ob die Installation von Puppeteer ordnungsgemäß verlaufen ist:

import puppeteer from 'puppeteer';

async function scrapeTwitterData(twitter_url: string): Promise<void> {

    // Launch Puppeteer

    const browser = await puppeteer.launch({

        headless: false,

    	  args: ['--start-maximized'],

    	  defaultViewport: null

    })

    // Create a new page

    const page = await browser.newPage()

    // Navigate to the target URL

    await page.goto(twitter_url)

    // Close the browser

    await browser.close()

}

scrapeTwitterData("https://twitter.com/netflix")

Hier öffnen wir ein Browserfenster, erstellen eine neue Seite, navigieren zu unserer Ziel-URL und schließen dann den Browser. Der Einfachheit halber und der visuellen Fehlersuche halber öffne ich das Browserfenster in maximierter Größe im nicht kopflosen Modus.

Werfen wir nun einen Blick auf die Struktur der Website und extrahieren wir nach und nach die vorherige Liste der Daten:

Auf den ersten Blick ist Ihnen vielleicht aufgefallen, dass die Struktur der Website ziemlich komplex ist. Die Klassennamen werden nach dem Zufallsprinzip generiert und nur sehr wenige HTML-Elemente sind eindeutig identifiziert.

Zu unserem Glück finden wir beim Navigieren durch die übergeordneten Elemente der angepeilten Daten das Attribut "data-testid". Eine kurze Suche im HTML-Dokument kann bestätigen, dass dieses Attribut das Element, auf das wir abzielen, eindeutig identifiziert.

Um den Profilnamen und das Handle zu extrahieren, wird daher das "div"-Element extrahiert, dessen "data-testid"-Attribut auf "UserName" gesetzt ist. Der Code wird wie folgt aussehen:

// Extract the profile name and handle

const profileNameHandle = await page.evaluate(() => {

    const nameHandle = document.querySelector('div[data-testid="UserName"]')

    return nameHandle ? nameHandle.textContent : ""

})

const profileNameHandleComponents = profileNameHandle.split('@')

console.log("Profile name:", profileNameHandleComponents[0])

console.log("Profile handle:", '@' + profileNameHandleComponents[1])

Da sowohl der Profilname als auch das Profilhandle dasselbe übergeordnete Element haben, erscheint das Endergebnis zusammenhängend. Um dies zu beheben, verwenden wir die Methode "split", um die Daten zu trennen.

Dann wenden wir dieselbe Logik an, um die Biografie des Profils zu extrahieren. In diesem Fall ist der Wert für das Attribut "data-testid" "UserDescription":

// Extract the user bio

const profileBio = await page.evaluate(() => {

    const location = document.querySelector('div[data-testid="UserDescription"]')

    return location ? location.textContent : ""

})

console.log("User bio:", profileBio)

Das Endergebnis wird durch die Eigenschaft "textContent" des HTML-Elements beschrieben.

Im nächsten Abschnitt der Profildaten finden wir den Standort, die Website und das Beitrittsdatum in derselben Struktur.

// Extract the user location

const profileLocation = await page.evaluate(() => {

    const location = document.querySelector('span[data-testid="UserLocation"]')

    return location ? location.textContent : ""

})

console.log("User location:", profileLocation)

// Extract the user website

const profileWebsite = await page.evaluate(() => {

    const location = document.querySelector('a[data-testid="UserUrl"]')

    return location ? location.textContent : ""

})

console.log("User website:", profileWebsite)

// Extract the join date

const profileJoinDate = await page.evaluate(() => {

    const location = document.querySelector('span[data-testid="UserJoinDate"]')

    return location ? location.textContent : ""

})

console.log("User join date:", profileJoinDate)

Um die Anzahl der Anhänger und Follower zu ermitteln, müssen wir einen etwas anderen Ansatz wählen. Sehen Sie sich den Screenshot unten an:

Es gibt kein "data-testid"-Attribut und die Klassennamen werden immer noch zufällig generiert. Eine Lösung wäre, die Ankerelemente ins Visier zu nehmen, da sie ein eindeutiges "href"-Attribut bieten.

// Extract the following count

const profileFollowing = await page.evaluate(() => {

    const location = document.querySelector('a[href$="/following"]')

    return location ? location.textContent : ""

})

console.log("User following:", profileFollowing)

// Extract the followers count

const profileFollowers = await page.evaluate(() => {

    const location = document.querySelector('a[href$="/followers"]')

    return location ? location.textContent : ""

})

console.log("User followers:", profileFollowers)

Um den Code für jedes Twitter-Profil verfügbar zu machen, haben wir den CSS-Selektor so definiert, dass er auf die Ankerelemente abzielt, deren "href"-Attribut mit "/following" bzw. "/followers" endet.

In der Liste der Tweets kann jeder einzelne mit dem Attribut "data-testid" identifiziert werden (siehe unten):

Der Code unterscheidet sich nicht von dem, was wir bis zu diesem Punkt getan haben, mit Ausnahme der Verwendung der Methode "querySelectorAll" und der Umwandlung des Ergebnisses in ein Javascript-Array:

// Extract the user tweets

const userTweets = await page.evaluate(() => {

    const tweets = document.querySelectorAll('article[data-testid="tweet"]')

    const tweetsArray = Array.from(tweets)

    return tweetsArray

})

console.log("User tweets:", userTweets)

Obwohl der CSS-Selektor sicherlich korrekt ist, haben Sie vielleicht bemerkt, dass die resultierende Liste fast immer leer ist. Das liegt daran, dass die Tweets ein paar Sekunden nach dem Laden der Seite geladen werden.

Die einfache Lösung für dieses Problem besteht darin, nach der Navigation zur Ziel-URL eine zusätzliche Wartezeit einzufügen. Eine Möglichkeit besteht darin, mit einer festen Anzahl von Sekunden zu spielen, eine andere darin, zu warten, bis ein bestimmter CSS-Selektor im DOM erscheint:

await page.waitForSelector('div[aria-label^="Zeitleiste: "]')

Hier weisen wir also unser Skript an zu warten, bis ein "div"-Element, dessen "aria-label"-Attribut mit "Timeline: " beginnt, auf der Seite sichtbar ist. Und jetzt sollte das vorherige Snippet einwandfrei funktionieren.

Nun können wir die Daten über den Autor des Tweets wie zuvor mit dem Attribut "data-testid" identifizieren.

Im Algorithmus werden wir die Liste der HTML-Elemente durchlaufen und die Methode "querySelector" auf jedes einzelne Element anwenden. Auf diese Weise können wir besser sicherstellen, dass die von uns verwendeten Selektoren eindeutig sind, da der Zielbereich viel kleiner ist.

// Extract the user tweets

const userTweets = await page.evaluate(() => {

    const tweets = document.querySelectorAll('article[data-testid="tweet"]')

    const tweetsArray = Array.from(tweets)

    return tweetsArray.map(t => {

        const authorData = t.querySelector('div[data-testid="User-Names"]')

        const authorDataText = authorData ? authorData.textContent : ""

        const authorComponents = authorDataText.split('@')

        const authorComponents2 = authorComponents[1].split('·')

        return {

            authorName: authorComponents[0],

            authorHandle: '@' + authorComponents2[0],

            date: authorComponents2[1],

        }

    })

})

console.log("User tweets:", userTweets)

Die Daten über den Autor werden auch hier verkettet erscheinen. Um sicherzustellen, dass das Ergebnis einen Sinn ergibt, wenden wir die "Split"-Methode auf jeden Abschnitt an.

Der Textinhalt des Tweets ist ziemlich einfach:

const tweetText = t.querySelector('div[data-testid="tweetText"]')

Für die Fotos des Tweets wird eine Liste von "img"-Elementen extrahiert, deren Eltern "div"-Elemente mit dem Attribut "data-testid" auf "tweetPhoto" gesetzt sind. Das Endergebnis ist das "src"-Attribut dieser Elemente.

const tweetPhotos = t.querySelectorAll('div[data-testid="tweetPhoto"] > img')

const tweetPhotosArray = Array.from(tweetPhotos)

const photos = tweetPhotosArray.map(p => p.getAttribute('src'))

Und schließlich der Statistikbereich des Tweets. Die Anzahl der Antworten, Retweets und Likes sind auf die gleiche Weise zugänglich, über den Wert des Attributs "aria-label", nachdem wir das Element mit dem Attribut "data-testid" identifiziert haben.

Um die Anzahl der Aufrufe zu ermitteln, zielen wir auf das Ankerelement ab, dessen "aria-label"-Attribut mit der Zeichenfolge "Views"endet.Tweet-Analysen anzeigen" endet.

const replies = t.querySelector('div[data-testid="reply"]')

const repliesText = replies ? replies.getAttribute("aria-label") : ''

const retweets = t.querySelector('div[data-testid="retweet"]')

const retweetsText = retweets ? retweets.getAttribute("aria-label") : ''

const likes = t.querySelector('div[data-testid="like"]')

const likesText = likes ? likes.getAttribute("aria-label") : ''

const views = t.querySelector('a[aria-label$="Views. View Tweet analytics"]')

const viewsText = views ? views.getAttribute("aria-label") : ''

Da das Endergebnis auch Zeichen enthält, verwenden wir die Methode "split", um nur den numerischen Wert zu extrahieren und zurückzugeben. Das vollständige Codeschnipsel zum Extrahieren von Tweets-Daten ist unten dargestellt:

// Extract the user tweets

const userTweets = await page.evaluate(() => {

    const tweets = document.querySelectorAll('article[data-testid="tweet"]')

    const tweetsArray = Array.from(tweets)

    return tweetsArray.map(t => {

        

        // Extract the tweet author, handle, and date

        const authorData = t.querySelector('div[data-testid="User-Names"]')

        const authorDataText = authorData ? authorData.textContent : ""

        const authorComponents = authorDataText.split('@')

        const authorComponents2 = authorComponents[1].split('·')

        // Extract the tweet content

        const tweetText = t.querySelector('div[data-testid="tweetText"]')

        // Extract the tweet photos

        const tweetPhotos = t.querySelectorAll('div[data-testid="tweetPhoto"] > img')

        const tweetPhotosArray = Array.from(tweetPhotos)

        const photos = tweetPhotosArray.map(p => p.getAttribute('src'))

        // Extract the tweet reply count

        const replies = t.querySelector('div[data-testid="reply"]')

        const repliesText = replies ? replies.getAttribute("aria-label") : ''

        // Extract the tweet retweet count

        const retweets = t.querySelector('div[data-testid="retweet"]')

        const retweetsText = retweets ? retweets.getAttribute("aria-label") : ''

        // Extract the tweet like count

        const likes = t.querySelector('div[data-testid="like"]')

        const likesText = likes ? likes.getAttribute("aria-label") : ''

        // Extract the tweet view count

        const views = t.querySelector('a[aria-label$="Views. View Tweet analytics"]')

        const viewsText = views ? views.getAttribute("aria-label") : ''

        return {

            authorName: authorComponents[0],

            authorHandle: '@' + authorComponents2[0],

            date: authorComponents2[1],

            text: tweetText ? tweetText.textContent : '',

            media: photos,

            replies: repliesText.split(' ')[0],

            retweets: retweetsText.split(' ')[0],

            likes: likesText.split(' ')[0],

            views: viewsText.split(' ')[0],

        }

    })

})

console.log("User tweets:", userTweets)

Nachdem Sie das gesamte Skript ausgeführt haben, sollte Ihr Terminal etwa so aussehen:

Profile name: Netflix

Profile handle: @netflix

User bio:

User location: California, USA

User website: netflix.com/ChangePlan

User join date: Joined October 2008

User following: 2,222 Following

User followers: 21.3M Followers

User tweets: [

  {

    authorName: 'best of the haunting',

    authorHandle: '@bestoffhaunting',

    date: '16 Jan',

    text: 'the haunting of hill house.',

    media: [

      'https://pbs.twimg.com/media/FmnGkCNWABoEsJE?format=jpg&name=360x360',

  	'https://pbs.twimg.com/media/FmnGkk0WABQdHKs?format=jpg&name=360x360',

  	'https://pbs.twimg.com/media/FmnGlTOWABAQBLb?format=jpg&name=360x360',

  	'https://pbs.twimg.com/media/FmnGlw6WABIKatX?format=jpg&name=360x360'

    ],

    replies: '607',

    retweets: '37398',

    likes: '170993',

    views: ''

  },

  {

    authorName: 'Netflix',

    authorHandle: '@netflix',

    date: '9h',

    text: 'The Glory Part 2 premieres March 10 -- FIRST LOOK:',

    media: [

  	'https://pbs.twimg.com/media/FmuPlBYagAI6bMF?format=jpg&name=360x360',

  	'https://pbs.twimg.com/media/FmuPlBWaEAIfKCN?format=jpg&name=360x360',

  	'https://pbs.twimg.com/media/FmuPlBUagAETi2Z?format=jpg&name=360x360',

  	'https://pbs.twimg.com/media/FmuPlBZaEAIsJM6?format=jpg&name=360x360'

    ],

    replies: '250',

    retweets: '4440',

    likes: '9405',

    views: '656347'

  },

  {

    authorName: 'Kurtwood Smith',

    authorHandle: '@tahitismith',

    date: '14h',

    text: 'Two day countdown...more stills from the show to hold you over...#That90sShow on @netflix',

    media: [

  	'https://pbs.twimg.com/media/FmtOZTGaEAAr2DF?format=jpg&name=360x360',

  	'https://pbs.twimg.com/media/FmtOZTFaUAI3QOR?format=jpg&name=360x360',

  	'https://pbs.twimg.com/media/FmtOZTGaAAEza6i?format=jpg&name=360x360',

  	'https://pbs.twimg.com/media/FmtOZTGaYAEo-Yu?format=jpg&name=360x360'

    ],

    replies: '66',

    retweets: '278',

    likes: '3067',

    views: ''

  },

  {

    authorName: 'Netflix',

    authorHandle: '@netflix',

    date: '12h',

    text: 'In 2013, Kai the Hatchet-Wielding Hitchhiker became an internet sensation   -- but that viral fame put his questionable past squarely on the radar of authorities. \n' +

  	'\n' +

  	'The Hatchet Wielding Hitchhiker is now on Netflix.',

    media: [],

    replies: '169',

    retweets: '119',

    likes: '871',

    views: '491570'

  }

]

Hochskalierung

Während das Scrapen von Twitter anfangs einfach erscheint, kann der Prozess komplexer und schwieriger werden, wenn Sie Ihr Projekt erweitern. Die Website setzt verschiedene Techniken zur Erkennung und Verhinderung von automatisiertem Datenverkehr ein, so dass Ihr Scraper in größerem Umfang eine Ratenbeschränkung erhält oder sogar blockiert wird.

Eine Möglichkeit, diese Herausforderungen zu überwinden und das Scraping in großem Maßstab fortzusetzen, ist die Verwendung einer Scraping-API. Diese Art von Diensten bietet eine einfache und zuverlässige Möglichkeit, auf Daten von Websites wie twitter.com zuzugreifen, ohne dass Sie einen eigenen Scraper entwickeln und pflegen müssen.

WebScrapingAPI ist ein Beispiel für ein solches Produkt. Sein Proxy-Rotationsmechanismus vermeidet Blöcke gänzlich, und seine erweiterte Wissensbasis macht es möglich, die Browserdaten zu randomisieren, so dass sie wie ein echter Benutzer aussehen.

Die Einrichtung ist schnell und einfach. Alles, was Sie tun müssen, ist, ein Konto zu registrieren, damit Sie Ihren API-Schlüssel erhalten. Auf diesen können Sie über Ihr Dashboard zugreifen, und er wird zur Authentifizierung der von Ihnen gesendeten Anfragen verwendet.

Da Sie Ihre Node.js-Umgebung bereits eingerichtet haben, können wir das entsprechende SDK verwenden. Führen Sie den folgenden Befehl aus, um es zu Ihren Projektabhängigkeiten hinzuzufügen:

npm install webscrapingapi

Jetzt müssen wir nur noch eine GET-Anfrage senden, um das HTML-Dokument der Website zu erhalten. Beachten Sie, dass dies nicht der einzige Weg ist, um auf die API zuzugreifen.

import webScrapingApiClient from 'webscrapingapi';

const client = new webScrapingApiClient("YOUR_API_KEY");

async function exampleUsage() {

    const api_params = {

        'render_js': 1,

        'proxy_type': 'residential',

        'wait_for_css': 'div[aria-label^="Timeline: "]',

        'timeout': 30000

    }

    const URL = "https://twitter.com/netflix"

    const response = await client.get(URL, api_params)

    if (response.success) {

        console.log(response.response.data)

    } else {

        console.log(response.error.response.data)

    }

}

exampleUsage();

Wenn Sie den Parameter "render_js" aktivieren, senden wir die Anfrage mit einem Headless-Browser, so wie Sie es zuvor in diesem Tutorial getan haben.

Nachdem Sie das HTML-Dokument erhalten haben, können Sie eine andere Bibliothek verwenden, um die gewünschten Daten zu extrahieren, z. B. Cheerio. Noch nie davon gehört? Dieser Leitfaden hilft Ihnen bei den ersten Schritten!

Schlussfolgerung

In diesem Artikel wurde eine umfassende Anleitung zum effektiven Web-Scraping von Twitter mit TypeScript vorgestellt. Wir haben die Schritte zum Einrichten der erforderlichen Umgebung, zum Auffinden und Extrahieren von Daten und zur möglichen Verwendung dieser Informationen behandelt.

Twitter ist eine wertvolle Datenquelle für diejenigen, die Einblicke in die Verbraucherstimmung, die Überwachung sozialer Medien und Business Intelligence gewinnen möchten. Es ist jedoch wichtig zu beachten, dass die Verwendung der Twitter-API allein möglicherweise nicht ausreicht, um auf alle benötigten Daten zuzugreifen, weshalb die Verwendung eines professionellen Scrapers die bessere Lösung ist.

Insgesamt kann Web Scraping Twitter wertvolle Erkenntnisse liefern und für jedes Unternehmen oder jede Einzelperson, die sich einen Wettbewerbsvorteil verschaffen will, eine große Hilfe sein.