Beste Screenshot-APIs in 2026: Top 7 im Vergleich

Eine Screenshot-API lässt dich jede Website per Code in ein Bild verwandeln — ohne Browser auf deiner Seite. Sende eine URL, erhalte ein PNG oder PDF. Entwickler nutzen sie für Social Cards, Site-Monitoring, automatisiertes Testen und Web-Archivierung.

Egal, ob du einen Managed Service willst oder lieber mit Puppeteer selbst hostest — dieser Guide deckt die sieben besten Screenshot-API-Optionen in 2026 mit echtem Code und ehrlichen Preisen ab.

Warum eine Screenshot-API nutzen?

Bevor du ein Tool wählst, hilft es zu wissen, warum du überhaupt eine Website-Screenshot-API willst. Hier die häufigsten Gründe:

• Social-Media-Cards — Erstelle Open-Graph-Bilder on-the-fly für Blogposts, Produktseiten oder Nutzerprofile
• Site-Monitoring — Erfasse visuelle Snapshots nach Zeitplan, um Layout-Brüche oder Ausfälle zu erkennen
• Automatisiertes Testen — Mache Screenshots in CI/CD-Pipelines für visuelle Regressionsprüfungen
• Web-Archivierung — Speichere Seitenzustände für Compliance, rechtliche oder Forschungszwecke
• PDF-Generierung — Verwandle Webseiten in druckfertige Dokumente

Wenn du deinen eigenen Mac-Bildschirm erfasst (keine Websites), bewältigt ein lokales Tool wie ScreenSnap Pro das mit schnellem Markup und Sharing. Aber für Webseiten-Screenshot-Erfassung im großen Maßstab brauchst du eine API.

SaaS vs Self-Hosted: welcher Ansatz passt?

Die erste Entscheidung ist, ob du einen Managed Service nutzt oder deine eigene Browser-Infrastruktur betreibst.

SaaS-APIs (ScreenshotOne, Urlbox, ApiFlash) betreiben die Browser für dich. Du zahlst pro Screenshot, sparst aber die ganze DevOps-Arbeit.

Self-Hosted-Tools (Puppeteer, Playwright) geben dir volle Kontrolle und keine Pro-Schuss-Kosten, aber du verwaltest Chrome, Speicher und Skalierung selbst.

Die 7 besten Screenshot-APIs im Vergleich

1. ScreenshotOne

ScreenshotOne ist für Entwickler gebaut, die eine schnelle, solide Screen-Capture-API ohne Aufwand brauchen.

Hauptfunktionen:

• Vollseitige und elementspezifische Aufnahmen
• Eingebauter Werbe- und Cookie-Banner-Blocker
• Dark-Mode-Rendering
• Geolokationsbasierte Aufnahmen (rendere, als wärst du in einem beliebigen Land)
• Antwortformate: PNG, JPEG, WebP, PDF

Code-Beispiel (Node.js):

const url = 'https://api.screenshotone.com/take'
  + '?access_key=YOUR_KEY'
  + '&url=https://example.com'
  + '&full_page=true'
  + '&format=png'
  + '&block_ads=true';

const response = await fetch(url);
const buffer = await response.arrayBuffer();

Preis: Kostenlose Stufe (100 Screenshots/Monat). Bezahlte Pläne ab 9 $/Monat für 1.500 Screenshots.

Am besten für: Teams, die eine polierte API mit sinnvollen Standards und minimalem Setup wollen.

2. Urlbox

Urlbox ist die Premium-Wahl für scharfe, hochwertige Website-Aufnahmen. Es bewältigt schwierige Seiten (SPAs, lazy-loaded Inhalte) besser als die meisten.

Hauptfunktionen:

• Retina (2x)-Rendering
• Vollseitige Aufnahmen mit automatischem Scroll-and-Stitch
• Eigene CSS/JS-Injektion vor der Aufnahme
• Webhook-Lieferung
• Direkter S3-Upload

Code-Beispiel (Python):

import requests

params = {
    'url': 'https://example.com',
    'full_page': 'true',
    'retina': 'true',
    'format': 'png',
    'width': 1920,
}
headers = {'Authorization': 'Bearer YOUR_API_KEY'}

response = requests.get(
    'https://api.urlbox.io/v1/render',
    params=params,
    headers=headers,
)

with open('screenshot.png', 'wb') as f:
    f.write(response.content)

Preis: Kostenlose Testphase. Pläne ab 29 $/Monat für 2.000 Renderings.

Am besten für: Teams, die pixelgenaue Aufnahmen komplexer, JavaScript-lastiger Seiten brauchen.

3. ApiFlash

ApiFlash läuft auf AWS Lambda, was es gut skalieren lässt. Die API ist einfach — ein Endpoint macht alles.

Hauptfunktionen:

• Auf Chrome und AWS Lambda gebaut
• Vollseitige und Viewport-Aufnahmen
• Automatische Seitenlade-Erkennung
• Werbeblockierung und Cookie-Banner-Entfernung
• Direkter Export in deinen S3-Bucket

Code-Beispiel (Node.js):

const params = new URLSearchParams({
  access_key: 'YOUR_KEY',
  url: 'https://example.com',
  full_page: 'true',
  response_type: 'image',
});

const response = await fetch(
  `https://api.apiflash.com/v1/urltoimage?${params}`
);
const buffer = await response.arrayBuffer();

Preis: Kostenlose Stufe (100 Screenshots/Monat). Lite-Plan bei 7 $/Monat für 1.000 Screenshots.

Am besten für: Budget-bewusste Projekte, die zuverlässige Aufnahmen ohne Premium-Preise brauchen.

4. Puppeteer (self-hosted)

Puppeteer ist Googles Node.js-Bibliothek zum Ausführen von Headless Chrome. Es ist das automatisierte Screenshot-Tool der Wahl für Entwickler, die volle Kontrolle wollen.

Hauptfunktionen:

• Voller Zugriff auf Chrome DevTools Protocol
• Seiteninteraktion vor der Aufnahme (klicken, scrollen, tippen)
• Netzwerk-Interception und Request-Blockierung
• PDF-Generierung
• Kostenlos und Open Source

Code-Beispiel (Node.js):

import puppeteer from 'puppeteer';

const browser = await puppeteer.launch();
const page = await browser.newPage();
await page.setViewport({ width: 1920, height: 1080 });
await page.goto('https://example.com', {
  waitUntil: 'networkidle0',
});
await page.screenshot({
  path: 'screenshot.png',
  fullPage: true,
});
await browser.close();

Preis: Kostenlos (Open Source). Du zahlst nur für Server-Infrastruktur.

Am besten für: Entwickler, die mit Node.js vertraut sind, maximale Flexibilität brauchen und nichts gegen Infrastruktur-Verwaltung haben.

5. Playwright (self-hosted)

Playwright ist Microsofts Antwort auf Puppeteer, mit Multi-Browser-Unterstützung und einer saubereren API. Viele Teams wählen es jetzt zum Erstellen von Screenshots per Code.

Hauptfunktionen:

• Unterstützt Chromium, Firefox und WebKit
• Eingebautes Auto-Waiting (keine manuellen Sleep-Aufrufe)
• Netzwerk-Mocking und -Interception
• Parallelisierte Test-Kontexte
• Python-, Node.js-, Java- und .NET-SDKs

Code-Beispiel (Python):

from playwright.sync_api import sync_playwright

with sync_playwright() as p:
    browser = p.chromium.launch()
    page = browser.new_page(viewport={'width': 1920, 'height': 1080})
    page.goto('https://example.com')
    page.screenshot(path='screenshot.png', full_page=True)
    browser.close()

Preis: Kostenlos (Open Source). Nur Infrastruktur-Kosten.

Am besten für: Teams, die Playwright-Screenshot-Tests über mehrere Browser hinweg machen, oder Python/Java-Shops, die kein Node.js wollen.

6. Screenshotlayer

Screenshotlayer ist eine der älteren Screenshot-APIs, Teil der APILayer-Familie. Es ist einfach, hat aber mit neueren Konkurrenten nicht Schritt gehalten.

Hauptfunktionen:

• Einfache REST-API
• Viewport-Anpassung
• Vollseitige Aufnahmen
• CSS-Injektion
• Mehrere Exportformate

Code-Beispiel (Node.js):

const url = 'https://api.screenshotlayer.com/api/capture'
  + '?access_key=YOUR_KEY'
  + '&url=https://example.com'
  + '&viewport=1920x1080'
  + '&fullpage=1';

const response = await fetch(url);

Preis: Kostenlose Stufe (100 Screenshots/Monat). Professional-Plan bei 40 $/Monat für 10.000 Screenshots.

Stärken: Kinderleichte API mit einem Endpoint. Die kostenlose Stufe funktioniert für Side Projects gut.

Limits: Die Docs und das Dashboard fühlen sich neben ScreenshotOne und Urlbox veraltet an. Das Ausführen von JavaScript vor der Aufnahme wird nicht gut unterstützt.

Am besten für: Schnelles Prototyping, wenn du schon andere APILayer-Dienste nutzt.

7. BrowserStack Screenshots

BrowserStack Screenshots ist für Cross-Browser-Testing gebaut, nicht für allgemeine Aufnahmen. Du wählst Browser- + OS-Kombinationen und bekommst Screenshots, wie deine Site auf jeder aussieht.

Hauptfunktionen:

• Über 3.000 Browser- und Geräte-Kombinationen
• Echte Geräte (keine Emulatoren) für mobile
• Side-by-side-Vergleichsansicht
• Integration mit BrowserStacks Test-Suite

Preis: Teil von BrowserStacks Test-Plänen ab 29 $/Monat.

Am besten für: QA-Teams, die Cross-Browser-Visual-Testing machen, nicht für allgemeine Screenshot-Aufnahmen.

Hinweis: BrowserStack ist primär eine Test-Plattform, sekundär ein Screenshot-Tool. Wenn du Screenshots für Social Cards oder Monitoring brauchst, passen die anderen Tools dieser Liste besser. Aber für Cross-Browser-QA schlägt nichts seine Geräteauswahl.

Schneller Preisvergleich

Die SaaS-APIs liegen bei 4-10 $ pro tausend Aufnahmen. Bei hohem Volumen (50.000+ pro Monat) wird Self-Hosting mit Puppeteer oder Playwright deutlich günstiger — wenn dein Team die Zeit hat, es zu verwalten.

Best Practices für Sicherheit und Authentifizierung

Wenn du eine Screenshot-API nutzt, gibst du einem Service Zugriff auf URLs — von denen einige privat sein können. Behalte diese Sicherheitstipps im Kopf:

Schütze deine API-Keys:

• Speichere Keys in Umgebungsvariablen, nie im Quellcode
• Nutze separate Keys für Dev und Produktion
• Rotiere Keys alle paar Monate, oder sofort, wenn einer leakt
• Die meisten SaaS-APIs lassen dich IP-Allowlists setzen — schalte das ein, damit nur deine Server Aufrufe machen können

Sei vorsichtig mit internen URLs:

• Übergib niemals interne Netzwerk-URLs (wie localhost oder 192.168.x.x) an eine SaaS-API — das könnte private Dienste offenlegen
• Wenn du interne Seiten erfassen musst, nutze ein Self-Hosted-Tool wie Puppeteer hinter deiner Firewall
• Manche APIs unterstützen signierte URLs, die ein zeitlich begrenztes Token hinzufügen, sodass der Link nicht wiederverwendet werden kann

Rate-Limiting und Missbrauch:

• Setze Rate-Limits auf deinen eigenen Endpoints, die Screenshot-Aufrufe auslösen — das stoppt böse Akteure davon, dein Kontingent zu verbrennen
• Füge eine Queue zwischen deine App und die API ein, damit Bursts keine Fehlschläge verursachen
• Logge jeden API-Aufruf mit URL und Zeitstempel für Audit-Trails

Auth für gesperrte Seiten:

• SaaS-APIs unterstützen Cookie-Injektion oder eigene Header — nutze diese für Seiten hinter einem Login
• Mit Puppeteer oder Playwright kannst du Login-Formulare direkt im Code ausfüllen
• Für extra Sicherheit erstelle einen Read-only-Account nur für Screenshots, sodass die API niemals Schreibzugriff auf deine App hat

Skalierungs-Tipps für Screenshot-Erfassung mit hohem Volumen

Wenn du Zehntausende von Aufnahmen pro Monat brauchst, sparst du mit Vorausplanung Geld und Kopfschmerzen:

Für SaaS-APIs:

• Nutze Webhook-Lieferung statt auf eine Antwort zu warten — das entlastet deinen Server, während der Screenshot rendert
• Cache Ergebnisse nach URL + Zeitstempel, damit du nicht für die Wieder-Erfassung derselben Seite zahlst
• Batch Anfragen während Off-Peak-Stunden, wenn Timing nicht kritisch ist — manche APIs bieten nachts geringere Latenz
• Überwache dein Nutzungs-Dashboard wöchentlich, um Spitzen zu erwischen, bevor sie dein Budget sprengen

Für Self-Hosted (Puppeteer/Playwright):

• Lass Chrome in einem Docker-Container mit strikten Speicher-Caps laufen (512 MB pro Instanz ist ein guter Start)
• Nutze eine Job-Queue wie BullMQ oder Celery, um zu kontrollieren, wie viele Browser gleichzeitig laufen
• Wiederverwende Browser-Instanzen über mehrere Seiten, statt jedes Mal eine neue zu starten — das reduziert die Startzeit um 2-3 Sekunden pro Schuss
• Richte Health Checks ein, die hängende Chrome-Prozesse neu starten (sie hängen manchmal)
• Für 100.000+ pro Monat verteile die Last über mehrere Server mit einem Load Balancer

Kostenrechnung im großen Maßstab:

Bei 100.000 Screenshots pro Monat:

• ScreenshotOne: ~50 $/Monat (Growth-Plan)
• Urlbox: ~100 $/Monat
• Self-hosted auf einem 20-$-VPS: bewältigt 50.000-100.000/Monat mit gutem Queue-Design

Der Break-Even-Punkt, an dem Self-Hosting gewinnt, liegt meist bei 30.000-50.000 pro Monat — aber nur, wenn du einen Entwickler hast, der das einrichten und am Laufen halten kann.

Gesponsert von den Machern

Genug von langweiligen Screenshots? Probier ScreenSnap Pro.

Wunderschöne Hintergründe, professionelle Annotationen, GIF-Aufnahme und sofortiges Cloud-Sharing — alles in einer App. Einmalig 29 $, für immer deins.

Sieh, was es kann

Wie wähle ich die richtige Screenshot-API

Hier ein praktisches Entscheidungsframework:

Wähle eine SaaS-API, wenn:

• Du Screenshots in unter einer Stunde am Laufen brauchst
• Dein Volumen unter 50.000 Screenshots/Monat liegt
• Du keine Chrome-Instanzen oder Container verwalten willst

Wähle Puppeteer, wenn:

• Du schon in einem Node.js-Stack bist
• Du mit Seiten interagieren musst, bevor du sie erfasst (Login, klicken, scrollen)
• Budget knapp ist, aber Engineering-Zeit verfügbar ist

Wähle Playwright, wenn:

• Du Multi-Browser-Aufnahmen brauchst (Chrome, Firefox, Safari)
• Dein Team Python, Java oder .NET nutzt
• Du Screenshot-Erfassung mit End-to-End-Tests kombinierst

Zum Erfassen deines eigenen Bildschirms — Screenshots annotieren, schnelle GIFs aufnehmen oder Bildschirmaufnahmen mit Audio greifen — ist ein Desktop-Tool wie ScreenSnap Pro die bessere Wahl. Screenshot-APIs lösen ein anderes Problem: das Rendern entfernter Webseiten als Bilder im großen Maßstab.

Praxis-Implementierung: Generierung von Social Preview Cards

Einer der beliebtesten Anwendungsfälle für eine Screen-Capture-API ist die Generierung dynamischer Open-Graph-Bilder. Statt eine Vorschau-Karte für jeden Blogpost von Hand zu designen, erstellst du ein HTML-Template und screenshootest es programmatisch.

Hier ein praktischer Workflow:

1. Baue ein HTML-Template mit dynamischen Feldern (Titel, Autor, Datum, Branding)
2. Hoste es lokal oder auf einem Staging-Server mit Query-Parametern für jedes Feld
3. Rufe deine Screenshot-API mit der Template-URL auf, um ein 1200×630-Bild zu generieren
4. Cache das Ergebnis in deinem CDN — regeneriere nur, wenn der Inhalt sich aktualisiert

Dieser Ansatz funktioniert mit jeder API auf dieser Liste. SaaS-Optionen wie ScreenshotOne machen es zu einem API-Aufruf. Mit Puppeteer kannst du das HTML direkt rendern, ohne es zu hosten:

await page.setContent(htmlTemplate);
await page.screenshot({ path: 'og-image.png' });

Das Ergebnis sind konstante, gebrandete Vorschau-Karten über Twitter, LinkedIn, Slack und Discord — ohne manuelle Design-Arbeit.

Umgang mit häufigen Herausforderungen

Screenshot-APIs funktionieren nicht immer beim ersten Versuch. Hier die Probleme, auf die Entwickler am häufigsten stoßen:

Lazy-loaded Inhalte fehlen. Viele Sites laden Bilder beim Scrollen. SaaS-APIs bewältigen das mit Scroll-and-Capture-Modi. Für Puppeteer scrolle die Seite per Code, bevor du den Schuss machst:

await page.evaluate(async () => {
  await new Promise((resolve) => {
    let totalHeight = 0;
    const timer = setInterval(() => {
      window.scrollBy(0, 200);
      totalHeight += 200;
      if (totalHeight >= document.body.scrollHeight) {
        clearInterval(timer);
        resolve();
      }
    }, 100);
  });
});

Cookie-Banner blockieren die Sicht. Die meisten SaaS-APIs haben eingebautes Banner-Blocking. Für Self-Hosted-Setups nutze CSS-Injektion (display: none auf gängige Consent-Popup-Selektoren) oder eine Browser-Adblocker-Erweiterung.

Seiten sehen je nach Region anders aus. Manche Sites ändern Inhalte basierend darauf, wo du bist. ScreenshotOne und Urlbox bieten proxybasierte Standort-Einstellungen. Für Self-Hosted-Tools route über ein VPN oder einen Proxy im Zielland.

Chrome frisst zu viel RAM. Jede Chrome-Instanz nutzt 50-300 MB Speicher. Im großen Maßstab brauchst du Process-Pooling, Container-Caps und Job-Queues. Das ist der Hauptgrund, warum Teams zu SaaS wechseln — Chrome im großen Maßstab zu betreiben ist eine echte Plage.

Seiten hinter Auth-Walls geben leere Screenshots zurück. Wenn du eine gesperrte URL ohne Login-Cookies an eine SaaS-API sendest, bekommst du stattdessen einen Login-Seiten-Screenshot. Übergib Session-Cookies oder Auth-Header mit der Anfrage. Für Self-Hosted-Tools skripte den vollständigen Login-Flow vor der Aufnahme.

Timeouts auf langsamen Seiten. Schwere Seiten können 10+ Sekunden zum Rendern brauchen. Erhöhe das Timeout-Setting in deinem API-Aufruf (die meisten Standards sind 30 Sekunden). Für Puppeteer setze timeout: 60000 in den goto()-Optionen. Wenn eine Seite weiterhin Timeout hat, versuche auf ein bestimmtes Element zu warten statt auf vollen Network-Idle.

Tipps für bessere Ergebnisse mit jeder Screenshot-API

Egal welche Take-Screenshot-API du wählst, diese Tipps bringen dir bessere Ergebnisse:

1. Setze eine klare Viewport-Größe. Standards variieren zwischen Diensten. Nutze 1920x1080 für Desktop und 375x812 für Mobile, um Konsistenz zu wahren.

1. Warte, bis die Seite vollständig lädt. Nutze waitUntil: 'networkidle0' in Puppeteer oder setze Delay-Optionen in SaaS-APIs. JS-lastige Seiten brauchen mehr Zeit.

1. Blocke Werbung und Cookie-Popups. Die meisten SaaS-APIs haben einen Toggle dafür. Für Self-Hosted nutze Adblocker-Plugins oder Netzwerk-Filter.

1. Nutze den Retina (2x)-Modus. Verdopple den Device-Scale für scharfe Bilder, besonders wenn die Aufnahmen auf High-DPI-Bildschirmen angezeigt werden.

1. Cache aggressiv. Wenn du Social-Preview-Cards machst, cache jeden Schuss und mache ihn nur neu, wenn der Inhalt sich ändert. Das spart Geld und beschleunigt deine Seiten.

Musst du deine erfassten Aufnahmen in ein anderes Format ändern? Unser kostenloser Bildformat-Konverter bewältigt PNG, JPG und WebP in Sekunden.

Jenseits von APIs: lokale Screenshot-Workflows

Screenshot-APIs bewältigen serverseitige Aufnahmen von Webseiten. Aber wenn du erfassen musst, was gerade auf deinem Mac-Bildschirm ist — ein Bug in deinem lokalen Dev-Setup, ein Design-Comp oder Terminal-Output — willst du ein lokales Tool.

Die eingebauten macOS-Shortcuts decken die Basics ab. Für mehr Power — wie Hintergründe hinzufügen, private Daten weichzeichnen oder über Cloud-Link teilen — füllt ScreenSnap Pro die Lücke zu einem Einmalpreis von 29 $.

Viele Dev-Teams nutzen beides: eine API für Site-Aufnahmen im großen Maßstab und ein Desktop-Tool für lokale Screenshots.

Für schnelles Teilen während Dev-Arbeit — Bug Reports in Slack, Code-Snippets für Docs oder Terminal-Output für Issue Tracker — schau dir unseren Guide zum Kopieren von Screenshots in die Zwischenablage an. Und wenn du Text aus Screenshots ziehen musst mit OCR, da glänzen lokale Tools.

Häufig gestellte Fragen

Was ist eine Screenshot-API?

Eine Screenshot-API ist ein Service, der eine URL nimmt und ein Bild (PNG, JPEG oder PDF) dieser Webseite zurückgibt. Er betreibt einen Headless-Browser auf seinen Servern, sodass du Chrome nicht selbst verwalten musst.

Sind Self-Hosted-Screenshot-Lösungen besser als SaaS-APIs?

Es kommt auf deinen Maßstab und dein Team an. Self-Hosted-Tools wie Puppeteer und Playwright kosten nichts pro Schuss, aber du musst Browser, Speicher und Skalierung verwalten. SaaS-APIs kosten mehr pro Aufnahme, entfernen aber alle Infrastruktur-Sorgen. Unter 50.000 Schüssen pro Monat ist SaaS meist insgesamt günstiger.

Können Screenshot-APIs Seiten hinter einem Login erfassen?

Ja. Die meisten SaaS-APIs lassen dich Cookies oder eigene Header für eingeloggte Seiten übergeben. Self-Hosted-Tools wie Puppeteer und Playwright können Login-Formulare direkt ausfüllen — Benutzername eintippen, Anmelden klicken, dann die Seite greifen.

Wie bewältigen Screenshot-APIs dynamischen JavaScript-Inhalt?

Gute Screenshot-APIs warten, bis die Seite vollständig gerendert ist, bevor sie den Schuss machen. SaaS-Tools wie ScreenshotOne und Urlbox erkennen das Seitenladen selbst. Mit Puppeteer nutzt du waitUntil: 'networkidle0' oder wartest auf das Erscheinen eines bestimmten Elements.

Was ist die beste kostenlose Screenshot-API?

ApiFlash und ScreenshotOne geben dir beide 100 kostenlose Schüsse pro Monat. Für unbegrenzte kostenlose Aufnahmen sind Puppeteer und Playwright Open Source — du zahlst nur für den Server. Ein kleines DigitalOcean-Droplet kann tausende Aufnahmen pro Monat für unter 10 $ bewältigen.

Können Screenshot-APIs PDFs aus Webseiten generieren?

Ja. Die meisten Screenshot-APIs können neben PNG und JPEG auch PDF ausgeben. Puppeteers page.pdf() gibt dir Kontrolle über Ränder, Header, Footer und Seitengröße. SaaS-APIs wie ScreenshotOne und Urlbox nehmen einen format=pdf-Parameter. Großartig zum Erstellen von Rechnungen, Berichten oder druckbarem Web-Inhalt.

Wie schnell sind Screenshot-APIs?

SaaS-APIs liefern Aufnahmen in 2-8 Sekunden zurück, abhängig von Seitengröße und Render-Einstellungen. Einfache statische Seiten brauchen unter 3 Sekunden. JS-lastige SPAs brauchen mehr Zeit. Self-Hosted-Puppeteer kann für lokale Ziele schneller sein, da kein Roundtrip zu einem Drittserver besteht. Wenn Geschwindigkeit zählt, schau nach APIs mit Webhook-Lieferung — sie rendern im Hintergrund und POSTen das Ergebnis an deinen Endpoint, wenn fertig.