Hoe Algolia Search te schrapen

Hier is een blogpost van meer dan 2000 woorden over "Hoe Algolia Search te schrapen":

Introductie

Algolia is een populaire zoek-API die de zoekfunctionaliteit voor veel websites op internet aanstuurt. Het stelt websites in staat snel en relevant zoeken te implementeren zonder zelf een complexe zoekinfrastructuur te hoeven gebruiken.

Enkele voorbeelden van populaire websites die Algolia gebruiken zijn:

Reddit
Medium
GitHub
StackOverflow
HackerNews

Het doel van dit bericht is om uit te leggen:

Wat is Algolia en hoe het werkt
Hoe Algolia-zoekresultaten te schrapen met Python
Technieken om Algolia efficiënt op schaal te schrapen
Hoe u kunt voorkomen dat u geblokkeerd raakt tijdens het schrapen van Algolia

Aan het einde zul je begrijpen hoe je een schaalbare Algolia-webschraper kunt bouwen voor elke website die er gebruik van maakt.

Wat is Algolia?

Algolia is een gehoste zoek-API die services biedt zoals indexering, zoeken en aanbevelingen. Het wordt vaak een Search-as-a-Service (SaaS)-provider genoemd.

De belangrijkste waardeproposities van Algolia zijn onder meer:

Snel zoeken – Algolia beweert in minder dan 100 ms meer dan miljarden records te kunnen doorzoeken. Dit is een orde van grootte sneller dan zoeken op uw eigen infrastructuur.
Relevante zoekopdracht – Algolia verwerkt zaken als typotolerantie, synoniemen en leren op basis van gebruikersgedrag om de meest relevante resultaten te retourneren.
Gehoste dienst – Algolia zorgt voor zaken als schaalvergroting en redundantie. Er is geen infrastructuur die u kunt beheren.
API toegang – De zoekfunctionaliteit is toegankelijk via API, wat een eenvoudige integratie in websites, mobiele apps, enz. mogelijk maakt.

Algolia biedt clientbibliotheken voor de meeste grote talen en frameworks die de API-communicatie afhandelen. Aan de front-end voegen ontwikkelaars JavaScript-code toe om te communiceren met de API van Algolia.

Samenvattend biedt Algolia gehoste en schaalbare zoekopdrachten via API. Hierdoor kunnen websites snel geweldige zoekresultaten bouwen zonder zelf complexe systemen te hoeven bouwen.

Algolia-zoekopdrachten schrappen met Python

Nu we begrijpen wat Algolia is, gaan we kijken hoe we de zoekresultaten van Algolia kunnen schrapen met behulp van Python.

Het schrapen van Algolia is eenvoudig omdat de API openbaar en gedocumenteerd is. We hoeven alleen maar:

Identificeer het API-eindpunt en de parameters
Pak eventuele toegangssleutels uit
Verzend zoekaanvragen en parseer het JSON-antwoord

Laten we een compleet voorbeeld bekijken van het schrapen van een door Algolia aangedreven website.

Het API-eindpunt vinden

Eerst moeten we het API-eindpunt vinden dat door de website wordt gebruikt voor zoeken. De eenvoudigste manier is om de site in uw browser te openen, een zoekopdracht uit te voeren en de netwerkverzoeken in de ontwikkelaarstools te controleren.

Bijvoorbeeld op HackerNews we zien een verzoek gericht aan:

https://hn.algolia.com/api/v1/search?query=python

De /api/v1/search pad verraadt dat dit de zoek-API van Algolia is. We zien ook de zoekterm python doorgegeven als een queryparameter.

Door het antwoord te controleren, kunnen we zien dat het JSON retourneert met de resultaten. We weten nu welk API-eindpunt en de zoekparameter we moeten gebruiken.

De API-sleutels verkrijgen

Vervolgens hebben we de API-sleutel nodig die nodig is om te authenticeren. Als we opnieuw het netwerkverzoek controleren, kunnen we zien dat het via de X-Algolia-API-Key header.

Wij kunnen deze API-sleutel extraheren en toevoegen aan onze verzoeken. Er kan aanvullende reverse engineering nodig zijn als de sleutel in JavaScript verborgen is.

Zoekopdrachten maken

Met het eindpunt en de API-sleutel kunnen we nu zoekopdrachten doen in Python:

import requests 

api_key = "abc123" # Extracted key 

search_url = "https://hn.algolia.com/api/v1/search"

params = {
  ‘query‘: ‘python‘,
  ‘hitsPerPage‘: 100, 
  ‘attributesToSnippet‘: [‘title:10‘]
}

headers = {
  "X-Algolia-API-Key": api_key
}

response = requests.get(search_url, params=params, headers=headers)
data = response.json()

print(data[‘hits‘])

We doen een GET-verzoek aan het API-eindpunt en geven onze zoekterm, hits per pagina en de API-sleutelheader door. Het resultaat bevat de zoekhits als JSON die we indien nodig kunnen parseren en verwerken.

En we hebben nu een basis Algolia schraper!

Extra pagina's schrapen

Eén beperking is dat de API alleen de eerste pagina met resultaten retourneert. Om extra pagina's te krijgen, moeten we de page parameter oplopend vanaf 0:

# First page
params[‘page‘] = 0 

# Second page
params[‘page‘] = 1 

# Third page
params[‘page‘] = 2

Om alle pagina's te schrapen, kunnen we verzoeken herhalen om het paginanummer te verhogen totdat er geen resultaten meer worden geretourneerd.

Dit samenvoegen:

from typing import Iterator

def scrape_search(search_term: str) -> Iterator[dict]:

  params = {
    ‘query‘: search_term,
    ‘hitsPerPage‘: 100,
  }

  page = 0
  while True:
    params[‘page‘] = page
    resp = requests.get(search_url, params=params, headers=headers)
    data = resp.json()

    if not data[‘hits‘]:
      break

    yield from data[‘hits‘]

    page += 1

Dit herhaalt zich over pagina's en levert alle resultaten op.

Om alle resultaten te verzamelen:

results = []

for result in scrape_search("python"):
  results.append(result)

print(len(results))

En we hebben nu een complete paginator om alle Algolia-zoekresultaten te schrapen!

Algolia op schaal schrapen

De bovenstaande basisschraper werkt, maar is niet geoptimaliseerd voor schrapen op grote schaal. Problemen waar u tegenaan kunt lopen:

Langzaam – Synchrone verzoeken zorgen ervoor dat het traag is om honderden pagina’s te schrapen.
Breekbaar – Eén fout verbreekt het hele schraapproces.
Banned – Als u van één IP-adres schrapt, loopt u het risico geblokkeerd te raken.

Laten we eens kijken hoe we deze problemen kunnen aanpakken voor robuust, grootschalig schrapen.

Asynchrone verzoeken

Om het scrapen te versnellen, kunnen we asynchrone verzoeken gebruiken. Hierdoor kunnen we veel verzoeken tegelijkertijd in behandeling hebben.

Bijvoorbeeld met de asyncio module:

import asyncio

async def fetch_page(page):
  params[‘page‘] = page
  resp = await asyncio.to_thread(requests.get, search_url, params=params) 
  return resp.json()

async def async_scrape():
  page = 0 
  while True:
    tasks = [asyncio.create_task(fetch_page(page + i)) for i in range(10)]
    results = await asyncio.gather(*tasks)

    for data in results:
      if not data[‘hits‘]:
        return

      for hit in data[‘hits‘]:
        yield hit

    page += 10

pages = async_scrape()

Hierdoor worden bij elke iteratie gelijktijdig 10 pagina's opgehaald. Bij asynchrone verzoeken is de scraper een orde van grootte sneller.

Nieuwe pogingen en fouttolerantie

Netwerkverzoeken zijn gevoelig voor periodieke fouten. We kunnen nieuwe pogingen toevoegen om fouten netjes af te handelen:

from time import sleep

async def fetch_page(page):

  for retry in range(3):

    try:
      return await asyncio.to_thread(requests.get, search_url, params=params) 
    except Exception as e:
      print(f"Error: {e}, retrying")
      sleep(1)

  print(f"Failed to fetch page {page} after {retries} retries")
  return {‘hits‘: []} # Return empty result

Bij elke fout wordt het eenvoudigweg tot 3 keer opnieuw geprobeerd. Andere verbeteringen, zoals exponentiële uitstel, kunnen ook worden toegevoegd.

Voor nog meer veerkracht kunnen we de algehele scraping-lus in een try/except plaatsen en het opnieuw proberen bij onverwachte crashes.

Met nieuwe pogingen op meerdere niveaus kan de scraper herstellen van verschillende fouten en blijven draaien.

Roterende proxy's

Als u te veel van één IP-adres schrapt, loopt u het risico geblokkeerd te raken. Om dit te voorkomen, kunnen we verzoeken via verschillende proxy's routeren met behulp van modules zoals requests-proxy-killer:

from proxy_killer import KillerScraper

scraper = KillerScraper(use_cache=False, max_retries=3)

async def fetch_page(page):

  for retry in range(3): 
    try:
      proxy = scraper.get_proxy() # Rotate proxy
      resp = scraper.get(search_url, proxies=proxy, params=params)
      return resp.json()
    except Exception as e:
      print(f"Error: {e}, retrying")
      sleep(1)

# Remainder same as above

Door elk verzoek via een ander proxy-IP te routeren, kunnen we op schaal schaven zonder ons zorgen te hoeven maken over blokkades.

Met de bovenstaande stappen kunnen we een robuuste, hoogwaardige, grootschalige Algolia-schraper in Python bouwen. Dezelfde principes zijn van toepassing op elke taal.

Blokken vermijden tijdens het schrapen van Algolia

Het laatste probleem dat moet worden aangepakt, is het vermijden van blokkades van de Algolia-service zelf. Als u te veel agressieve verzoeken indient, kan Algolia uw IP-adres blokkeren of verzoeken beperken.

Hier zijn enkele tips om beleefd te schrapen en blokkades te minimaliseren:

Limiettarief: Overweldig de API niet met honderden gelijktijdige verzoeken. Begin klein en verhoog geleidelijk.
Gebruik proxy's: Roteer verschillende IP's om de belasting te verdelen en geconcentreerde verzoeken te voorkomen.
Willekeurige user-agents: Varieer de user-agent header tussen verzoeken.
Volg robots.txt: Zorg ervoor dat uw schraper de robots.txt-regels naleeft.
Gebruik logica voor opnieuw proberen: Exponentieel uitstel als uw tarief beperkt of geblokkeerd wordt.
Schraap tijdens periodes met weinig verkeer: Doel op doordeweekse nachten wanneer de belasting lager is.
Zorgvuldig in de gaten houden: Controleer op toenemende storingen of beperking.

Met de juiste zorg kunt u duurzame, langlopende Algolia-schrapers bouwen. Maar zorg ervoor dat u uw aanpak in de loop van de tijd nauwlettend in de gaten houdt en aanpast.

Helperbibliotheken schrapen

Het handmatig afhandelen van alle complexiteit van schaalvergroting en veerkracht kan lastig zijn. Er bestaan verschillende commerciële tools om webscrapen te vereenvoudigen.

Bijvoorbeeld:

SchrapenBee – Verwerkt proxy's, CAPTCHA's en browsers.
SchraperAPI – Browser-API met automatische proxyrotatie.
proxycrawl – Residentiële proxy's met headless browser.

Deze tools maken het eenvoudiger om robuuste scrapers te bouwen zonder dat u zelf complexe logica hoeft te coderen. Zie mijn gids op hoe en wanneer u een scraping-API moet gebruiken.

Afsluiten

Dit zijn de belangrijkste tips:

Algolia biedt gehoste zoekopdrachten via API voor eenvoudige integratie in sites.
De zoek-API is openbaar en kan worden geschraapt door het eindpunt en de sleutels te extraheren.
Voor scrapen op schaal zijn asynchrone verzoeken en proxyrotatie vereist.
Houd goed in de gaten en schraap beleefd om blokkades te voorkomen.
Commerciële schraapdiensten kunnen grote schraapklussen vereenvoudigen.

Ik hoop dat dit bericht een goed overzicht geeft van hoe je de Algolia-zoek-API op grote schaal effectief kunt schrapen met Python. Dezelfde principes zijn ook van toepassing op andere talen.

Laat het me weten als je nog vragen hebt!