Immobiliendaten-Extraktion automatisierengeplante Immobilieninserate mit Crawlbase

Öffentliche Immobilieninserate gehören zu den nützlichsten Daten im offenen Web. Preis, Zimmeranzahl, Badezimmer, Quadratmeter und Adresse stehen auf jeder Ergebnisseite, und die Verfolgung, wie sich diese Zahlen im Laufe der Zeit verschieben, verrät Ihnen, wo ein Markt heiß läuft, wo Mieten nachlassen und welche Inserate falsch bepreist sind. Der Haken ist, dass ein einzelner Snapshot selten genug ist. Immobiliendaten sind nur dann wertvoll, wenn sie aktuell sind, was bedeutet, dass Sie sie immer wieder nach einem Zeitplan sammeln müssen, ohne an einem Terminal zu sitzen und jeden Lauf zu überwachen.

Diese Anleitung zeigt Ihnen, wie Sie Immobiliendaten-Extraktion automatisieren mit JavaScript und Node.js. Sie erstellen einen ausführbaren Workflow, der öffentliche Inserate über die Crawling API abruft, Preis, Zimmer, Bäder, Quadratmeter, Adresse und Link für jede Immobilie parst und das Ganze dann auf drei Arten automatisiert: ein geplanter Cron-Lauf für stetige Sammlung, den asynchronen Crawler mit einem Webhook für hohes Volumen und einen einfachen Store für die Ergebnisse. Wenn Sie nur ein einmaliges Scrape einer einzelnen Site benötigen, passen die verlinkten sitespezifischen Anleitungen besser. Diese hier handelt davon, den Job wiederholt auszuführen. Alles hier ist auf öffentliche Insertdaten beschränkt, und der rechtliche Abschnitt am Ende ist kein Boilerplate, also lesen Sie ihn, bevor Sie das auf echtes Volumen anwenden.

Was Sie erstellen werden

Ein Node.js-Workflow, der eine öffentliche Immobiliensuche-URL entgegennimmt, das gerenderte HTML über die Crawling API abruft, für jedes Inserat auf der Seite einen strukturierten Datensatz extrahiert und nach einem Zeitplan läuft. Für jede Immobilie ziehen wir diese Felder heraus:

• Preis der aufgelistete Preis wie auf der Karte angezeigt, zum Beispiel "$2.400/Monat" oder "$525.000".
• Zimmer die Anzahl der Schlafzimmer.
• Bäder die Anzahl der Badezimmer.
• Quadratmeter die Wohnfläche in Quadratfuß.
• Adresse die im Inserat angezeigte Straßenadresse.
• Link die URL zur individuellen Insertsseite.

Zusätzlich zum Parser verdrahten Sie drei Automatisierungsebenen: einen geplanten Lauf, einen asynchronen Hochvolumenpfad und einen JSON-Store mit einem Zeitstempel auf jedem Batch, sodass Sie eine Sammlung mit der nächsten vergleichen können.

Warum eine einfache Anfrage bei Immobiliensites scheitert

Wenn Sie eine Immobiliensuch-URL mit einem einfachen HTTP-Client anfordern, erhalten Sie selten das Listing-Raster zurück. Zwei Dinge arbeiten gegen Sie. Erstens rendern die meisten modernen Immobilienportale ihre Ergebnisse im Browser mit JavaScript, sodass das initiale HTML eine nahezu leere Hülle ist, bis die Skripte der Seite ausgeführt werden. Zweitens kennzeichnen diese Sites automatisierten Traffic aggressiv: Datacenter-IPs und Anfragemuster, die nicht wie ein echter Browser aussehen, werden mit einem CAPTCHA herausgefordert, rate-limitiert oder blockiert, bevor sie die gerenderten Inserate erreichen.

Ein funktionierender Immobilien-Scraper benötigt also zwei Dinge in einer Anfrage: einen Browser, der die Seite tatsächlich rendert, und eine IP, die die Plattform als echten Besucher einliest. Sie können das selbst mit einem Headless-Browser plus einem Pool rotierender residenzieller Proxys zusammensetzen, aber deren Zusammenspiel und Wartung ist der größte Teil der Arbeit, und es wird schlimmer, wenn Sie nach einem Zeitplan laufen und das Volumen steigt. Die Crawling API vereint beides in einem einzigen Aufruf: Sie senden die URL, sie rendert die Seite hinter einer vertrauenswürdigen IP und gibt fertiges HTML zum Parsen mit Cheerio zurück.

Voraussetzungen

Sie benötigen ein paar Dinge, bevor Sie Code schreiben. Keines davon dauert lange.

Grundlegendes JavaScript und Node.js. Sie sollten mit dem Schreiben und Ausführen eines Node-Skripts sowie der Installation von Paketen mit npm vertraut sein. Gerade genug, um Funktionen zu lesen, ist ausreichend.

Node.js 16 oder neuer. Prüfen Sie Ihre Version mit node --version. Falls nicht vorhanden, installieren Sie es von der Node.js-Website oder über einen Versionsmanager wie nvm.

Ein Crawlbase-Konto und Token. Registrieren Sie sich, öffnen Sie Ihr Dashboard und kopieren Sie Ihr Token. Das kostenlose Tier gibt Ihnen bis zu 20.000 Anfragen ohne Kreditkarte. Behandeln Sie das Token wie ein Passwort: Es authentifiziert Ihre Anfragen, halten Sie es also aus der Versionskontrolle heraus.

Das Projekt einrichten

Erstellen Sie einen Projektordner, initialisieren Sie ihn und installieren Sie die Bibliotheken, die der Workflow benötigt.

node --version

mkdir real-estate-automation && cd real-estate-automation
npm init -y

npm install crawlbase cheerio node-cron express

Vier Abhängigkeiten erledigen die Arbeit: crawlbase ist der offizielle Node-Client für die Crawling API und den asynchronen Crawler, cheerio parst das zurückgegebene HTML mit einer jQuery-ähnlichen API, sodass Sie Felder per CSS-Selektor herausziehen können, node-cron führt das Scrape nach einem Zeitplan aus, und express empfängt den Webhook, den der asynchrone Crawler zurücksendet. Erstellen Sie eine Datei namens scraper.js in diesem Ordner und fügen Sie den Code aus den untenstehenden Schritten hinzu.

Schritt 1: Eine gerenderte Insertseite abrufen

Beginnen Sie damit, die fertige Seite zu erhalten. Importieren Sie die CrawlingAPI-Klasse, initialisieren Sie sie mit Ihrem Token und fordern Sie eine öffentliche Such-URL an. Da die Seite JavaScript-gerendert ist, übergeben Sie { ajax_wait: true, page_wait: 3000 }, damit die API wartet, bis die Insertkarten geladen sind, bevor sie zurückgibt. Das Prüfen des Statuscodes vor dem Parsen macht Fehler laut statt stumm.

const { CrawlingAPI } = require('crawlbase');

const api = new CrawlingAPI({ token: 'YOUR_CRAWLBASE_TOKEN' });

const listingsURL = 'https://www.example-realty.com/homes-for-rent/ca/los-angeles';

api
  .get(listingsURL, { ajax_wait: true, page_wait: 3000 })
  .then((response) => {
    if (response.statusCode === 200) {
      console.log(response.body.slice(0, 500));
    }
  })
  .catch((error) => console.error('API request error:', error));

Führen Sie das Skript mit node scraper.js aus und Sie sollten echtes Insertinventar am Anfang des Body sehen, keine abgespeckte Hülle. Das bestätigt, dass das Rendering funktioniert, bevor Sie einen einzigen Selektor schreiben. Tauschen Sie listingsURL gegen die öffentliche Suche, die Sie verfolgen möchten: eine Stadt, ein Viertel, eine Preisklasse. Die URL, die die Site anzeigt, wenn Sie eine Suche im Browser filtern, ist die, die Sie crawlen.

Schritt 2: Jedes Inserat mit Cheerio parsen

Mit gerendertem HTML in der Hand laden Sie es in Cheerio und gehen die Insertkarten durch. Eine Ergebnisseite legt jede Immobilie in einem sich wiederholenden Container dar, sodass Sie jede Karte auswählen und dann Preis, Zimmer, Bäder, Quadratmeter, Adresse und Link von innen lesen. Die genauen Selektoren unten stammen aus einem typischen Karten-Layout; Sie passen sie an die Site an, die Sie ansteuern, indem Sie eine Karte in den Dev-Tools Ihres Browsers inspizieren. Jedes Feld defensiv zu lesen verhindert, dass ein fehlender Wert den Run zum Absturz bringt, und das Parsen des Preises in eine Zahl gibt Ihnen etwas zum Sortieren und Vergleichen.

const cheerio = require('cheerio');

function parseListings(html) {
  const $ = cheerio.load(html);
  const properties = [];

  $('li[data-testid="listing-card"]').each((i, el) => {
    const card = $(el);

    const price = card.find('span.listing-card-price').text().trim();
    const priceValue = parseFloat(price.replace(/[^0-9.]/g, ''));

    const beds = card.find('p:contains("Beds") strong').first().text().trim();
    const baths = card.find('p:contains("Baths") strong').first().text().trim();
    const sqft = card.find('p:contains("Sq Ft") strong').first().text().trim();

    const address = card.find('a.listing-card-address').text().trim();
    const href = card.find('a.listing-card-address').attr('href');
    const link = href
      ? new URL(href, 'https://www.example-realty.com').href
      : '';

    if (price && address) {
      properties.push({ price, priceValue, beds, baths, sqft, address, link });
    }
  });

  return properties;
}

Einige Details halten das der Seite treu. Jede Karte sitzt in einem sich wiederholenden li-Container, der Preis kommt aus dem Preis-Span und wird auch in ein numerisches priceValue geparst, damit Sie günstigste zuerst sortieren können, und Zimmer, Bäder und Quadratmeter werden aus beschrifteten Blöcken mit einem :contains()-Selektor gelesen, der kleine Neuordnungen übersteht. Der Adressanker verdoppelt sich als Insertlink, sodass ein find Ihnen beides gibt, und das Href wird zu einer absoluten URL aufgelöst, damit es außerhalb der Seite funktioniert. Nur Karten mit einem Preis und einer Adresse werden gepusht, was die Promo-Kacheln herausfiltert, die Immobiliensites in ein Ergebnisraster mischen.

Schritt 3: Das Scrape zusammensetzen und Ergebnisse speichern

Verdrahten Sie jetzt den Abruf und das Parsen in eine Funktion, die saubere Datensätze zurückgibt, und schreiben Sie jeden Batch mit einem Zeitstempel auf die Festplatte. Das Aufbewahren jedes Runs in einer eigenen zeitgestempelten Datei ist das, was Ihnen erlaubt, eine Sammlung mit der nächsten zu vergleichen und Preisbewegungen zu beobachten.

const fs = require('fs');

async function scrape(url) {
  const response = await api.get(url, { ajax_wait: true, page_wait: 3000 });
  if (response.statusCode !== 200) {
    console.error(`Request failed: ${response.statusCode}`);
    return [];
  }
  return parseListings(response.body);
}

function save(properties) {
  properties.sort((a, b) => a.priceValue - b.priceValue);
  const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
  const file = `listings_${timestamp}.json`;
  fs.writeFileSync(file, JSON.stringify(properties, null, 2));
  console.log(`Saved ${properties.length} properties to ${file}`);
  return file;
}

async function runOnce() {
  const url = 'https://www.example-realty.com/homes-for-rent/ca/los-angeles';
  const properties = await scrape(url);
  if (properties.length) save(properties);
}

module.exports = { scrape, save, runOnce, parseListings };

Fügen Sie die parseListings-Funktion aus Schritt 2 und das API-Setup aus Schritt 1 in dieselbe Datei ein, damit scrape sie aufrufen kann. Führen Sie node -e "require('./scraper').runOnce()" aus und erhalten Sie eine sortierte, zeitgestempelte JSON-Datei jedes öffentlichen Inserats auf der Seite. Das ist die Arbeitseinheit, die die untenstehenden Automatisierungsebenen planen und wiederholen.

Mit einem Zeitplan automatisieren

Ein einmaliges Scrape erfasst einen einzelnen Moment. Immobiliendaten sind nur nützlich, wenn sie aktuell sind, sodass die erste Automatisierungsebene ein wiederkehrender Lauf ist. Mit node-cron halten Sie den Prozess am Leben und lösen runOnce auf einem Cron-Ausdruck aus. Das untenstehende Beispiel läuft jeden Morgen um 7 Uhr.

const cron = require('node-cron');
const { runOnce } = require('./scraper');

// Minute Hour DayOfMonth Month DayOfWeek
cron.schedule('0 7 * * *', async () => {
  console.log(`Scheduled run at ${new Date().toISOString()}`);
  try {
    await runOnce();
  } catch (error) {
    console.error('Scheduled run failed:', error.message);
  }
});

console.log('Scheduler started. Waiting for the next run...');

Starten Sie es mit node schedule.js und lassen Sie es auf einem kleinen Server oder einem Container laufen. Jeden Morgen scrapt es die Suche und legt eine frische zeitgestempelte Datei ab, die eine Historie aufbaut, die Sie für Preisänderungen, neue Inserate und Immobilien, die vom Markt gefallen sind, vergleichen können. Wenn Sie keinen Prozess am Leben halten möchten, funktioniert derselbe runOnce-Aufruf von einem System-Cron-Eintrag oder einem beliebigen Job-Runner; node-cron ist nur die In-Prozess-Option. Das Muster ist identisch mit dem im Leitfaden über wie man Amazon-Scraping automatisiert, wo ein Zeitplan ein einzelnes Scrape in eine Tracking-Pipeline verwandelt.

Mit dem asynchronen Crawler und einem Webhook hochskalieren

Eine geplante Schleife ist für eine Handvoll Suchen in Ordnung. Sobald Sie Dutzende von Städten oder Tausende von Insertseiten verfolgen, wird das Warten auf jede synchrone Anfrage der Reihe nach langsam, und ein langläufiger Prozess ist ein fragiler Ort, so viel Arbeit zu halten. Der asynchrone Crawler ist dafür gebaut: Sie pushen URLs an ihn, Crawlbase ruft sie auf seiner eigenen Infrastruktur ab und rendert sie, und es sendet jede fertige Seite an einen Webhook, den Sie hosten. Ihr Code hört auf, auf Anfragen zu warten, und behandelt nur Ergebnisse, wenn sie ankommen.

Richten Sie zunächst einen kleinen Endpunkt ein, der die Callbacks empfängt. Der Crawler sendet das gerenderte HTML dorthin, sodass Sie direkt im Handler parsen und speichern.

const express = require('express');
const { parseListings, save } = require('./scraper');

const app = express();
app.use(express.text({ type: '*/*', limit: '10mb' }));

app.post('/crawlbase-webhook', (req, res) => {
  const html = req.body;
  const properties = parseListings(html);
  if (properties.length) save(properties);
  res.sendStatus(200);
});

app.listen(3000, () => console.log('Webhook listening on :3000'));

Pushen Sie dann Ihre Such-URLs an den Crawler und nennen Sie dabei den Webhook als Callback. Der Crawler stellt jede in die Warteschlange, rendert sie und ruft Ihren Endpunkt mit dem Ergebnis auf, sodass Sie einen großen Batch einreichen und die Antworten zurückstreamen lassen können.

const { Crawler } = require('crawlbase');

const crawler = new Crawler({ token: 'YOUR_CRAWLBASE_TOKEN' });

const searches = [
  'https://www.example-realty.com/homes-for-rent/ca/los-angeles',
  'https://www.example-realty.com/homes-for-rent/ca/san-diego',
  'https://www.example-realty.com/homes-for-rent/ca/san-francisco',
];

for (const url of searches) {
  crawler.post(
    url,
    { callback: 'true', callback_url: 'https://your-server.com/crawlbase-webhook' },
    { ajax_wait: true, page_wait: 3000 }
  );
}

Die Aufteilung ist der Punkt. Der Crawler absorbiert den langsamen, blockierenden Teil, das Rendering und die Wiederholungsversuche, auf Crawlbases Seite, und Ihr Webhook führt immer nur den schnellen Parse-und-Speichern-Schritt aus. Diese Entkopplung ist das, was denselben Workflow von drei Suchen auf dreitausend skalieren lässt, ohne dass Ihr Prozess jede Anfrage offen hält. Ihr Webhook benötigt während der Entwicklung eine öffentliche URL; ein Tunneling-Tool legt localhost:3000 offen, sodass der Crawler es erreichen kann.

Wie die Ausgabe aussieht

Ob ein Datensatz vom geplanten Lauf oder dem asynchronen Webhook kommt, jeder Batch hat dieselbe Form: ein Objekt pro Inserat, günstigste zuerst sortiert, mit Preis, Zimmer, Bäder, Quadratmeter, Adresse und Link.

[
  {
    "price": "$2,400/mo",
    "priceValue": 2400,
    "beds": "2",
    "baths": "1",
    "sqft": "850",
    "address": "1234 Sunset Blvd, Los Angeles, CA 90026",
    "link": "https://www.example-realty.com/property/1234-sunset-blvd"
  },
  {
    "price": "$3,150/mo",
    "priceValue": 3150,
    "beds": "3",
    "baths": "2",
    "sqft": "1,320",
    "address": "88 Maple Ave, Los Angeles, CA 90042",
    "link": "https://www.example-realty.com/property/88-maple-ave"
  }
]

Da jeder Lauf in einer eigenen zeitgestempelten Datei landet, ist der Vergleich zweier Batches ein Set-Unterschied auf dem link-Feld für neue und entfernte Inserate und ein Join auf link mit einem priceValue-Vergleich für Preisänderungen. Dieser Vergleich ist der ganze Grund für die Automatisierung: Ein einzelnes Scrape sagt Ihnen, wie der Markt heute ist, eine geplante Historie sagt Ihnen, wohin er geht. Wenn Sie dieselben Datensätze in einer Tabellenkalkulation möchten, schrieb die Vorgängerversion dieses Workflows direkt in Excel mit ExcelJS, und das Hinzufügen dieses Exports ist ein paar Zeilen oben auf dem JSON-Store.

Bei Volumen nicht blockiert werden

Selbst mit gehandhabtem Rendering achten Immobilienportale auf scraper-förmigen Traffic, und ein Zeitplan, der jeden Tag auslöst, macht Muster leicht erkennbar. Einige Gewohnheiten halten einen Run gesund.

• Tempo Ihrer Anfragen. Verteilen Sie Fetches, anstatt Seiten in einer engen Schleife zu hämmern. Wenn Sie viele Suchen scrapen, fügen Sie eine Verzögerung zwischen ihnen hinzu oder setzen Sie auf den asynchronen Crawler, der die Arbeit in die Warteschlange stellt und für Sie pacast.
• Auf Rotation setzen. Ein Pool residenzieller IPs verteilt Anfragen über viele echte Nutzeradressen, sodass keine einzelne ein Limit oder ein CAPTCHA auslöst. Die Crawling API und der asynchrone Crawler erledigen das für Sie; wenn Sie Ihren eigenen Stack aufbauen, ist das der Teil, den Sie richtig machen müssen.
• Statuscodes lesen. Ein Run, der beginnt, Herausforderungen oder Nicht-200-Antworten zurückzugeben, sagt Ihnen, dass die aktuelle Rate oder IP-Stufe nicht mehr ausreicht. Behandeln Sie das als Signal zum Zurückhalten, nicht als Rauschen, das Sie ignorieren können.

Für das breitere Playbook lesen Sie, wie man Websites scrapet ohne blockiert zu werden. Wenn Sie stattdessen eine sitespezifische Anleitung und nicht diesen Automatisierungsfokus möchten, behandeln die dedizierten Anleitungen über wie man Zillow scrapt und wie man Redfin scrapt die spezifischen Karten-Layouts und Paginierung dieser Portale.

Ist es legal, Immobiliendaten zu scrapen?

Ob das Scrapen einer Immobiliensite erlaubt ist, hängt von den Nutzungsbedingungen dieser Site, Ihrer Gerichtsbarkeit und dem ab, was Sie mit den Daten tun. Die meisten Portale schränken den automatisierten Zugriff in ihren Bedingungen ein, sodass Scraping unabhängig von der Sorgfalt Ihres Toolings gegen diese Bedingungen verstoßen kann. Keiner des hier stehenden Codes ändert das; er macht nur den technischen Teil funktionsfähig. Lesen Sie die Nutzungsbedingungen der Site und ihre robots.txt und behandeln Sie beides als Grenze für das, was Sie sammeln und wie oft Sie anfragen. Ein Zeitplan macht Raten-Disziplin wichtiger, nicht weniger.

Halten Sie die Arbeit auf öffentliche Insertdaten beschränkt: den Preis, Zimmer, Bäder, Quadratmeter, Adresse und Insertlink, den jeder ohne Konto auf einer öffentlichen Ergebnisseite sehen kann. Sammeln Sie keine personenbezogenen Daten über Makler, Eigentümer oder Käufer über das hinaus, was ein öffentliches Geschäftsinserat bereits zeigt, und erstellen Sie keine Profile von Einzelpersonen daraus. DSGVO und CCPA gelten, sobald personenbezogene Daten ins Bild kommen, und eine öffentliche Straßenadresse, die mit einer benannten Person verbunden ist, kann sich qualifizieren, also konzentrieren Sie sich auf die Immobiliendaten und weg von den Menschen. Verteilen Sie keine urheberrechtlich geschützten Medien eines Portals, wie Insertsfotos, als wären sie Ihre eigenen, und greifen Sie nicht auf etwas hinter einem Login zu.

Ein Punkt, der spezifisch für diese Branche ist: Ein Großteil der wertvollsten Immobiliendaten kommt aus dem MLS, und MLS-Feeds sind fast immer lizenziert und nicht zum freien Nehmen. Wenn Ihr Projekt umfassende, genaue, weiterverteilbare Insertdaten benötigt, ist der richtige Weg ein lizenzierter Feed oder eine offizielle API, kein Scraper. Mehrere große Portale betreiben Partner-Programme oder Entwickler-APIs genau aus diesem Grund. Nutzen Sie diese, wenn Sie Volumen, garantierte Struktur oder kommerzielle Rechte benötigen. Diese Anleitung ist bewusst auf öffentliche Inserate auf öffentlichen Suchseiten beschränkt, weil das die Linie ist, die die Arbeit verteidigbar hält.

Häufig gestellte Fragen

Wie automatisiere ich die Extraktion von Immobiliendaten nach einem Zeitplan?

Verpacken Sie Ihr Scrape in eine Funktion und rufen Sie sie von einem Scheduler auf. Die einfachste In-Prozess-Option ist node-cron: Geben Sie ihm einen Cron-Ausdruck wie 0 7 * * * und es löst Ihre runOnce-Funktion jeden Morgen aus. Jeder Lauf legt eine frische zeitgestempelte Datei ab, sodass Sie eine Historie ansammeln, die Sie vergleichen können. Wenn Sie keinen Node-Prozess am Leben halten möchten, funktioniert dieselbe Funktion von einem System-Cron-Eintrag oder einem beliebigen Job-Runner.

Wann sollte ich den asynchronen Crawler statt der Crawling API verwenden?

Verwenden Sie die synchrone Crawling API, wenn Sie eine Handvoll Suchen scrapen und das Ergebnis im selben Aufruf zurückwollen. Wechseln Sie zum asynchronen Crawler, wenn Sie Dutzende von Städten oder Tausende von Insertseiten verfolgen: Sie pushen die URLs, Crawlbase rendert sie auf seiner eigenen Infrastruktur und sendet jede fertige Seite an einen Webhook, den Sie hosten. Diese Entkopplung verhindert, dass Ihr Prozess auf jede langsame Anfrage der Reihe nach wartet.

Warum gibt eine einfache Anfrage unvollständige Daten von Immobiliensites zurück?

Weil die meisten Portale ihr Insertionsraster clientseitig mit JavaScript rendern und automatisierten Traffic mit CAPTCHAs herausfordern. Eine rohe HTTP-Anfrage von einer Datacenter-IP gibt normalerweise eine leere Hülle oder eine Blockseite zurück, keine Immobilienkarten. Um eine vollständige Seite zu erhalten, müssen Sie sie hinter einer vertrauenswürdigen IP rendern, was die Crawling API für Sie erledigt, wenn Sie die JavaScript-Optionen übergeben.

Welche Felder kann ich aus einem öffentlichen Immobilieninserat extrahieren?

Die öffentlichen Fakten auf einer Ergebniskarte: Preis, Anzahl der Zimmer, Anzahl der Badezimmer, Quadratmeter, die Straßenadresse und der Link zur vollständigen Insertsseite. Diese Anleitung parst genau diese. Bleiben Sie weg von personenbezogenen Daten über Makler, Eigentümer oder Käufer und von urheberrechtlich geschützten Medien wie Insertsfotos, die beide rechtliche und lizenzrechtliche Einschränkungen mit sich bringen, die öffentliche Immobiliendaten nicht haben.

Meine Selektoren geben leere Werte zurück. Was hat sich geändert?

Höchstwahrscheinlich das Markup der Site. Insertkarten-Klassennamen und data-testid-Werte werden generiert und ändern sich ohne Vorankündigung, sodass Selektoren, die letzten Monat funktioniert haben, brechen können, besonders in einem Zeitplan, der unbeaufsichtigt läuft. Überprüfen Sie eine Live-Karte in den Dev-Tools Ihres Browsers und aktualisieren Sie den Selektor. Periodische Selektor-Wartung ist bei jedem Produktions-Scraper normal.

Ist es besser zu scrapen oder einen MLS-Feed zu verwenden?

Für umfassende, genaue, weiterverteilbare Insertdaten ist ein lizenzierter MLS-Feed oder eine offizielle Portal-API das richtige Werkzeug, da MLS-Daten fast immer lizenziert und nicht zum freien Nehmen sind. Das Scrapen öffentlicher Suchseiten ist angemessen für das Verfolgen öffentlicher Insertfakten in bescheidenem Volumen, Forschung und Preisbewegungsanalyse, auf öffentliche Daten und innerhalb der Bedingungen jeder Site beschränkt. Passen Sie die Quelle an den Einsatz an: öffentliche Fakten und geringes Volumen bevorzugen einen Scraper, umfassende oder kommerzielle Nutzung bevorzugt einen lizenzierten Feed.

HO

Henry Obinna

Freiberuflicher Content-Autor

Freiberuflicher Content-Autor, der Anleitungen zu Web Scraping und Open-Source-Tools zum Crawlbase-Blog beigetragen hat.