Bilder von DeviantArt scrapenöffentliche Galerien herunterladen

DeviantArt ist eine der größten Online-Communities für digitale Künstler, in der täglich Millionen von Mitgliedern Gemälde, Illustrationen, Fotos, Pixel-Art und Konzeptwerke veröffentlichen. Die öffentlichen Such- und Galerieseiten sind ein nützlicher Index dafür, welche Stile im Trend liegen, wer in einem bestimmten Genre publiziert und wie ein Werk organisiert ist. Das ist genau die Art von Katalog, den ein Forschungsprojekt, ein persönliches Mood-Board oder eine Studie zu visuellen Trends lieber programmatisch liest, als manuell zu scrollen.

Diese Anleitung zeigt Ihnen, wie Sie mit Python Bilder von DeviantArt scrapen. Sie erstellen einen kleinen, lauffähigen Scraper, der eine gerenderte öffentliche Suchseite über die Crawling API abruft, jedes Ergebnis mit BeautifulSoup parst, die Metadaten des Kunstwerks sammelt und die Thumbnail-Dateien auf die Festplatte lädt. Die gesamte Anleitung beschränkt sich auf öffentliche Galerieseiten, und der Abschnitt zur Rechtslage am Ende ist kein Boilerplate: DeviantArt-Kunstwerke sind durch das Urheberrecht ihrer Ersteller geschützt. Lesen Sie diesen Teil daher, bevor Sie den Scraper auf echte Daten ansetzen.

Was Sie bauen werden

Ein Python-Skript, das eine öffentliche DeviantArt-Such-URL entgegennimmt, das gerenderte HTML über die Crawling API abruft und für jedes Kunstwerk im Ergebnisraster einen strukturierten Datensatz extrahiert. Als durchgängiges Beispiel verwenden wir eine Keyword-Suche und lesen diese Felder aus jeder Ergebniskarte:

• Titel der Titel des Kunstwerks, zum Beispiel "Owl #6".
• Artist der DeviantArt-Benutzername des Autors, ausgelesen aus dem Deviation-Link.
• Image URL die im Ergebnisraster angezeigte Thumbnail-Bildquelle.
• Page URL der Link zur individuellen Deviation-Seite.
• Favourites die öffentliche Favoritenanzahl, sofern die Karte sie ausweist.
• Views die öffentliche Aufrufanzahl, sofern die Karte sie ausweist.

Warum ein einfacher Request bei DeviantArt scheitert

Wenn Sie eine DeviantArt-Such-URL mit einem einfachen HTTP-Client anfordern, erhalten Sie eine Antwort mit Status 200, aber kaum Kunstwerkdaten im Body. Zwei Faktoren arbeiten gegen Sie. Erstens baut DeviantArt sein Ergebnisraster im Browser mit JavaScript auf, sodass das initiale HTML eine Hülle ist, die sich erst nach Ausführung der Seitenskripte füllt. Zweitens erkennt die Plattform automatisierten Traffic schnell: Datacenter-IPs und Anfragemuster, die nicht nach einem echten Browser aussehen, werden gechallengt oder blockiert, bevor sie überhaupt die gerenderten Thumbnails erreichen.

Ein funktionierender DeviantArt-Scraper benötigt daher zwei Dinge in einer einzigen Anfrage: einen Browser, der die Seite tatsächlich rendert, und eine IP-Adresse, die die Plattform als echten Besucher einordnet. Das lässt sich selbst mit einem Headless-Browser plus einem Pool rotierender Residential-Proxys zusammensetzen, aber das Zusammenführen und Pflegen dieser Komponenten ist der aufwändigste Teil. Die Crawling API fasst beides in einem einzigen Aufruf zusammen: Sie übergeben ihr die URL mit einem JavaScript-Token, sie rendert die Seite hinter einer vertrauenswürdigen IP und liefert fertiges HTML zur Weiterverarbeitung zurück.

Voraussetzungen

Sie benötigen einige Dinge, bevor Sie Code schreiben. Keines davon nimmt viel Zeit in Anspruch.

Grundlegendes Python-Wissen. Sie sollten in der Lage sein, ein Python-Skript zu schreiben und auszuführen sowie Pakete mit pip zu installieren. Falls BeautifulSoup neu für Sie ist, behandelt unser Leitfaden zur Verwendung von BeautifulSoup in Python die Parse-Grundlagen, die dieses Tutorial voraussetzt.

Python 3.8 oder höher. Prüfen 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 ein JS-Token. Registrieren Sie sich, öffnen Sie Ihr Dashboard und kopieren Sie Ihr JavaScript-Token (JS-Token) von der Account-Docs-Seite. Behandeln Sie das Token wie ein Passwort: Es authentifiziert Ihre Anfragen, halten Sie es also aus der Versionskontrolle heraus.

Projekt einrichten

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

python --version

python -m venv deviantart_env
source deviantart_env/bin/activate

pip install crawlbase beautifulsoup4 requests

Unter Windows aktivieren Sie die Umgebung mit deviantart_env\Scripts\activate statt der source-Zeile. Drei Abhängigkeiten erledigen die Arbeit: crawlbase ist der offizielle Client für die Crawling API, beautifulsoup4 parst das zurückgegebene HTML, sodass Sie einzelne Felder per CSS-Selector extrahieren können, und requests streamt die Bilddateien im letzten Schritt auf die Festplatte.

Schritt 1: Die gerenderte Suchseite abrufen

Beginnen Sie damit, die fertig gerenderte Seite zu holen. Importieren Sie die CrawlingAPI-Klasse, initialisieren Sie sie mit Ihrem JS-Token und fordern Sie eine aus einem Keyword zusammengesetzte Such-URL an. Der Suchpfad von DeviantArt ist /search?q=KEYWORD, sodass eine Suche nach "fantasy" ein Raster mit öffentlichen Ergebnissen liefert. Die Statusprüfung vor dem Parsen macht Fehler sofort sichtbar, anstatt sie zu verschleiern.

from crawlbase import CrawlingAPI

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

base_url = "https://www.deviantart.com"

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("latin1")
    print(f"Request failed: {response['status_code']}")
    return None

if __name__ == "__main__":
    keyword = "fantasy"
    search_url = f"{base_url}/search?q={keyword}"
    html = crawl(search_url)
    print(html[:500] if html else "No HTML returned")

Die beiden Wait-Optionen sind bei einem clientseitig gerenderten Ziel wichtig. ajax_wait wartet auf das Ende asynchroner Inhalte, und page_wait hält eine festgelegte Anzahl von Millisekunden nach dem Laden an, damit spät gerenderte Thumbnails vor der Seitenerfassung erscheinen. Fünf Sekunden sind ein vernünftiger Ausgangswert; erhöhen Sie den Wert, wenn das Raster leer zurückkommt. Der Body wird als latin1 dekodiert, damit die rohen Bytes sauber durchgereicht werden. Führen Sie das Skript mit python scraper.py aus, und Sie sollten echtes Kunstwerk-Markup sehen, nicht die leere Hülle eines einfachen Fetches. Das bestätigt, dass das Rendering funktioniert, bevor Sie einen einzigen Selector schreiben.

Schritt 2: Die Kunstwerk-Karten mit BeautifulSoup parsen

Mit dem gerenderten HTML laden Sie es in BeautifulSoup und extrahieren jedes Ergebnis per Selector. DeviantArt umhüllt jedes Thumbnail in einem Deviation-Link, sodass Sie alle diese Links einmalig auswählen und anschließend dieselben Felder aus jedem Link lesen. Klicken Sie mit der rechten Maustaste auf ein Thumbnail in Ihrem Browser, wählen Sie "Untersuchen" und Sie finden eine Struktur wie die folgende.

<a data-hook="deviation_link"
   href="https://www.deviantart.com/siobhan-o-wisp/art/Owl-6-925596734"
   aria-label="Owl #6 by Siobhan-o-wisp, visual art">
  <div data-testid="thumb" typeof="ImageObject">
    <img alt="Owl #6" src="src_url_here" property="contentUrl" />
  </div>
</a>

Das gibt Ihnen alles, was Sie von einer Karte benötigen. Der Anker enthält die Deviation-Seiten-URL in href sowie Titel und Künstler in aria-label, und das eingebettete img enthält das Thumbnail in src. Der CSS-Selector für ein Thumbnail-Bild lautet a[data-hook="deviation_link"] img[property="contentUrl"], und den Titel des Kunstwerks erreichen Sie über das alt-Attribut des Bildes. Hier ist der Parser.

from bs4 import BeautifulSoup

def artist_from_url(page_url):
    # DeviantArt page URLs look like /<username>/art/<slug>
    parts = page_url.split("/")
    return parts[3] if len(parts) > 3 else None

def count_for(link, label):
    el = link.select_one(f'span[aria-label*="{label}"]')
    return el.get_text(strip=True) if el else None

def parse_artworks(html):
    soup = BeautifulSoup(html, "html.parser")
    links = soup.select('a[data-hook="deviation_link"]')
    artworks = []

    for link in links:
        img = link.select_one('img[property="contentUrl"]')
        if not img:
            continue
        page_url = link.get("href")
        artworks.append({
            "title": img.get("alt"),
            "artist": artist_from_url(page_url),
            "image_url": img.get("src"),
            "page_url": page_url,
            "favourites": count_for(link, "Favourites"),
            "views": count_for(link, "Views"),
        })

    return artworks

Der Titel stammt aus dem alt-Attribut des Bildes, der Künstler aus dem Benutzernamen-Segment der Deviation-URL und das Thumbnail aus src. Die Favoritenanzahl und die Aufrufzahlen befinden sich in kleinen beschrifteten Spans; count_for fragt per aria-label-Text ab und gibt None zurück, wenn eine Karte diese Zahl nicht anzeigt, sodass eine fehlende Anzahl die Schleife nie abbricht. Nicht jedes Ergebnis zeigt seine Statistiken im Raster an, weshalb beide Felder optional sind.

Schritt 3: Den Scraper zusammensetzen

Verbinden Sie nun Fetch und Parse zu einem lauffähigen Skript, fügen Sie Pagination hinzu, um mehr als das erste Raster abrufen zu können, und schreiben Sie das Ergebnis als JSON. DeviantArt paginiert die Suche mit einem &page=-Parameter, sodass eine kleine Schleife über Seitennummern einen breiteren Ergebnissatz sammelt. Pausieren Sie zwischen Anfragen, damit Sie die Website in einer Multi-Seiten-Ausführung nicht in einer engen Schleife belasten.

import json
import time
from crawlbase import CrawlingAPI
from bs4 import BeautifulSoup

api = CrawlingAPI({"token": "YOUR_CRAWLBASE_JS_TOKEN"})
base_url = "https://www.deviantart.com"

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("latin1")
    print(f"Request failed: {response['status_code']}")
    return None

def artist_from_url(page_url):
    parts = page_url.split("/")
    return parts[3] if len(parts) > 3 else None

def count_for(link, label):
    el = link.select_one(f'span[aria-label*="{label}"]')
    return el.get_text(strip=True) if el else None

def parse_artworks(html):
    soup = BeautifulSoup(html, "html.parser")
    links = soup.select('a[data-hook="deviation_link"]')
    artworks = []
    for link in links:
        img = link.select_one('img[property="contentUrl"]')
        if not img:
            continue
        page_url = link.get("href")
        artworks.append({
            "title": img.get("alt"),
            "artist": artist_from_url(page_url),
            "image_url": img.get("src"),
            "page_url": page_url,
            "favourites": count_for(link, "Favourites"),
            "views": count_for(link, "Views"),
        })
    return artworks

def main():
    keyword = "fantasy"
    total_pages = 2
    results = []
    for page in range(1, total_pages + 1):
        url = f"{base_url}/search?q={keyword}&page={page}"
        html = crawl(url)
        if html:
            results.extend(parse_artworks(html))
        time.sleep(3)

    with open("deviantart_data.json", "w") as f:
        json.dump(results, f, indent=2)
    print(f"Saved {len(results)} artworks")

if __name__ == "__main__":
    main()

Jede Seite teilt dieselbe Kartenstruktur, sodass der bereits geschriebene Parser auf allen Seiten ohne Änderungen funktioniert. Das time.sleep(3) zwischen Anfragen verhindert, dass ein mehrseitiger Durchlauf die Website überlastet. Erhöhen Sie total_pages nur so weit, wie Sie tatsächlich benötigen, und beobachten Sie die Statuscodes dabei.

Wie die Ausgabe aussieht

Führen Sie das vollständige Skript mit python scraper.py aus und erhalten Sie für jedes Kunstwerk einen sauberen strukturierten Datensatz, der in JSON, CSV oder eine Datenbank geschrieben werden kann.

[
  {
    "title": "Owl #6",
    "artist": "siobhan-o-wisp",
    "image_url": "https://images-wixmp-ed30a86b8c4ca887773594c2.wixmp.com/f/.../owl_6.jpg",
    "page_url": "https://www.deviantart.com/siobhan-o-wisp/art/Owl-6-925596734",
    "favourites": "412",
    "views": "3.1K"
  },
  {
    "title": "Magic Forest",
    "artist": "postapodcast",
    "image_url": "https://images-wixmp-ed30a86b8c4ca887773594c2.wixmp.com/f/.../magic_forest.png",
    "page_url": "https://www.deviantart.com/postapodcast/art/Magic-Forest",
    "favourites": null,
    "views": null
  }
]

Die Bild-URLs verweisen auf das CDN von DeviantArt (den wixmp.com-Host), und Favoriten- sowie Aufrufzahlen kommen bei Karten, die ihre Statistiken nicht anzeigen, als null zurück, was erwartet ist. Mit dieser Liste können Sie die Metadaten indexieren, analysieren oder mit dem Download der Thumbnail-Dateien fortfahren.

Schritt 4: Die Bilddateien herunterladen

Die Datensätze enthalten Thumbnail-URLs, nicht die Bild-Bytes. Um die Dateien lokal zu speichern, streamen Sie jede URL mit requests auf die Festplatte. Das Streaming in Chunks hält den Speicherbedarf auch bei größeren Bildern niedrig, und raise_for_status verwandelt einen fehlgeschlagenen Download in einen abgefangenen Fehler statt in eine lautlos leere Datei.

import os
import requests

def download_image(url, save_path):
    try:
        response = requests.get(url, stream=True, timeout=30)
        response.raise_for_status()
        with open(save_path, "wb") as file:
            for chunk in response.iter_content(chunk_size=8192):
                file.write(chunk)
        print(f"Saved {save_path}")
    except requests.exceptions.RequestException as e:
        print(f"Error downloading {url}: {e}")

def download_all(artworks, folder="downloaded_images"):
    os.makedirs(folder, exist_ok=True)
    for i, art in enumerate(artworks):
        url = art.get("image_url")
        if not url:
            continue
        artist = art.get("artist") or "unknown"
        path = os.path.join(folder, f"{artist}_{i}.jpg")
        download_image(url, path)

Rufen Sie download_all(results) nach dem Scrapen auf, und jedes Thumbnail landet in einem Ordner downloaded_images, benannt nach dem Benutzernamen des Künstlers und einem Index. Die Benennung nach Künstler hält die Zuordnung bei der Datei, was hier wichtig ist, weil jedes dieser Bilder der Person gehört, die es erstellt hat. Lesen Sie den nächsten Abschnitt, bevor Sie etwas speichern, das Sie für mehr als einen flüchtigen Blick verwenden wollen.

Nicht blockiert werden

Auch wenn das Rendering bereits gehandhabt wird, beobachtet DeviantArt weiterhin Scraper-typischen Traffic. Einige Gewohnheiten halten einen Durchlauf gesund, und sie gelten für jedes schwierige Ziel.

• Anfragen drosseln. Suchseiten in einer engen Schleife zu hämmern ist der schnellste Weg zur Drosselung. Das time.sleep in der Schleife ist aus genau diesem Grund vorhanden; behalten Sie es.
• Rotation nutzen. Ein Pool von Residential-IPs verteilt Anfragen über viele echte Nutzeradressen, sodass keine einzelne davon ein Rate-Limit auslöst. Die Crawling API erledigt das für Sie; wenn Sie einen eigenen Stack aufbauen, ist das der Teil, den Sie richtig hinbekommen müssen.
• Statuscodes lesen. Ein Durchlauf, der beginnt, Challenges oder Fehler zurückzugeben, signalisiert Ihnen, dass die aktuelle Rate oder IP-Stufe nicht mehr ausreicht. Behandeln Sie das als Signal zum Zurückrudern, nicht als Rauschen, das Sie ignorieren können.

Das umfassendere Playbook finden Sie unter how to scrape websites without getting blocked. Wenn Ihr Ziel wie DeviantArt clientseitig gerendert wird, erklärt unsere Anleitung zum Crawlen von JavaScript-Websites, warum Rendering wichtig ist. Und wenn Sie lieber Ihren eigenen Traffic über einen rotierenden Pool leiten möchten statt die verwaltete API zu verwenden, bietet der Smart AI Proxy (auch AI Proxy genannt) dieselbe Residential-IP-Rotation als Drop-in-Proxy-Endpunkt.

Ist das Scrapen von DeviantArt legal?

Das ist der Teil, der auf einer kreativen Plattform am wichtigsten ist, also überfliegen Sie ihn nicht. Die technische Arbeit in dieser Anleitung ist die einfache Hälfte; die Rechtsfrage ist die schwierige Hälfte. Ob das Scrapen von DeviantArt erlaubt ist, hängt von den Nutzungsbedingungen von DeviantArt, Ihrer Rechtsprechung und dem ab, was Sie mit den Daten tun. Die Nutzungsbedingungen von DeviantArt schränken den automatisierten Zugriff ein, sodass das Scrapen gegen diese Bedingungen verstoßen kann, unabhängig davon, wie sorgfältig Ihre Tools sind. Lesen Sie die Nutzungsbedingungen von DeviantArt und dessen robots.txt und behandeln Sie beides als Grenze für das, was Sie sammeln.

Die wichtigste Tatsache hier: Jedes Kunstwerk auf DeviantArt ist durch das Urheberrecht des Künstlers geschützt, der es erstellt hat. Eine öffentliche Thumbnail-URL oder einen Titel zu sammeln ist eine Sache; was Sie dann mit diesem Bild tun, ist eine andere, und das Gesetz unterscheidet beides. Verteilen, republizieren, verkaufen oder auf heruntergeladenen Kunstwerken Modelle trainieren Sie ohne ausdrückliche Genehmigung des Erstellers nicht. Begrenzen Sie Ihre Arbeit auf die Indexierung von Metadaten und das Speichern von Thumbnails für persönliche, Forschungs- oder genuinen internen Studienzwecke, und behalten Sie den Namen des Künstlers dabei, damit die Zuordnung nie verloren geht. Ein gescraptes Bild ist keine Lizenz, und "es war öffentlich" ist keine Genehmigung.

Diese Anleitung beschränkt sich bewusst auf öffentliche Galerie- und Suchseiten, weil das die Grenze ist, die die Arbeit vertretbar hält. Sie umfasst nichts hinter einem Login, nichts mit Altersbeschränkung, Konto- oder persönliche Daten oder Versuche, Authentifizierung oder Content-Gates zu umgehen. Nur öffentliche, nicht zugangsbeschränkte Kunstwerk-Metadaten. Wenn Ihr Projekt mehr als das benötigt, ist der offizielle Weg die DeviantArt OAuth API, die Deviations und Metadaten unter Bedingungen bereitstellt, die die Plattform tatsächlich gewährt. Für alles über die persönliche Nutzung hinaus, insbesondere die kommerzielle Weiterverwendung, ist die offizielle API plus die Genehmigung des Künstlers der richtige Weg, kein ausgefeilterer Scraper.

Häufig gestellte Fragen

Warum liefert ein einfacher Fetch kein Kunstwerk von DeviantArt?

Weil DeviantArt sein Suchraster clientseitig mit JavaScript aufbaut. Das initiale HTML ist eine Hülle, die sich erst nach Ausführung der Seitenskripte in einem Browser füllt, sodass ein roher HTTP-Request Status 200 mit leerem Raster zurückgibt. Um echte Daten zu erhalten, müssen Sie die Seite zunächst rendern, was das JS-Token der Crawling API für Sie übernimmt.

Benötige ich das normale Token oder das JS-Token für DeviantArt?

Das JS-Token. Das normale Token ruft statisches HTML ab, das auf der Suchseite von DeviantArt dieselbe leere Hülle wie ein einfacher Fetch ist. Das JS-Token rendert die Seite in einem echten Browser, bevor es das HTML zurückgibt, sodass die Thumbnails und ihre Metadaten vorhanden sind, wenn BeautifulSoup sie parst.

Wie scrappe ich mehr als die erste Seite der Ergebnisse?

DeviantArt paginiert die Suche mit einem &page=-Parameter. Schleifen Sie über die benötigten Seitennummern, erstellen Sie für jede eine URL wie /search?q=fantasy&page=2, rufen Sie sie über die Crawling API ab und wenden Sie denselben Parser an. Halten Sie zwischen Anfragen einen kurzen Sleep ein, damit ein mehrseitiger Durchlauf die Website nicht überlastet.

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

Höchstwahrscheinlich das Markup von DeviantArt. Klassennamen und interne Attribute ändern sich ohne Vorankündigung, sodass Selektoren, die letzten Monat funktionierten, brechen können. Die Schema-Hooks data-hook="deviation_link" und property="contentUrl" sind am haltbarsten, aber untersuchen Sie ein Live-Thumbnail in den Entwicklertools Ihres Browsers und aktualisieren Sie die Selektoren, wenn ein Feld leer zurückkommt.

Kann ich die von DeviantArt heruntergeladenen Bilder weiterverwenden oder verkaufen?

Nein, nicht ohne die Erlaubnis des Künstlers. Jede Deviation ist durch das Urheberrecht ihres Erstellers geschützt, sodass das Herunterladen eines öffentlichen Thumbnails Ihnen keine Lizenz zum Verteilen, Republizieren, Verkaufen oder Trainieren darauf gewährt. Beschränken Sie Downloads auf persönliche, Forschungs- oder interne Studienzwecke, nennen Sie den Künstler, und holen Sie für jede Weiterverwendung eine ausdrückliche Genehmigung ein oder nutzen Sie eine Lizenzvereinbarung über den offiziellen Kanal.

Gibt es eine offizielle DeviantArt API, die ich stattdessen verwenden sollte?

Ja. DeviantArt bietet eine OAuth API an, die Deviations und ihre Metadaten unter von der Plattform direkt gewährten Bedingungen bereitstellt. Für alles über die gelegentliche persönliche Nutzung hinaus, insbesondere für kommerzielle Projekte, ist die offizielle DeviantArt OAuth API der empfohlene Weg und derjenige, der Sie auf der richtigen Seite sowohl der Nutzungsbedingungen als auch des Urheberrechts hält.

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.