Back to blog
2026-03-19

Deflato-API verwenden: Entwickler-Tutorial

Warum eine Bildkomprimierungs-API nutzen?

Manuelle Bildkomprimierung skaliert nicht. Wenn Ihre Anwendung Nutzer-Uploads, Thumbnails, Produktkataloge oder statische Websites verarbeitet, brauchen Sie programmatische Bildoptimierung. Eine API komprimiert, skaliert und konvertiert Bilder als Teil Ihres automatisierten Workflows — CI/CD-Pipeline, Serverless Function, CMS-Webhook oder Background Job.

Die Deflato-API bietet eine einfache REST-Schnittstelle. Unterstützte Eingabeformate: JPEG, PNG, WebP, AVIF, HEIC, TIFF und PDF. Ausgabe: JPEG, WebP und AVIF.

API-Key erhalten

  1. Account erstellen auf deflato.com.
  2. Einstellungen → API im Dashboard navigieren.
  3. API-Key generieren — wird nur einmal angezeigt.
  4. Key sicher speichern. Umgebungsvariablen verwenden (DEFLATO_API_KEY).

Das kostenlose Kontingent umfasst 100 API-Komprimierungen pro Monat. Pro- und Team-Pläne bieten höhere Limits.

API-Grundlagen: cURL-Beispiele

Endpoint für Bildkomprimierung:

POST https://deflato.com/api/v1/compress

Akzeptiert multipart/form-data mit Bilddatei und optionalen Parametern.

Einfache Komprimierung

# JPEG mit Standardeinstellungen komprimieren
curl -X POST https://deflato.com/api/v1/compress   -H "Authorization: Bearer $DEFLATO_API_KEY"   -F "file=@photo.jpg"   --output compressed.jpg

Ohne Parameter: gleiches Ausgabeformat, Qualität 80, keine Skalierung, EXIF entfernt.

Formatkonvertierung

# JPEG nach WebP konvertieren
curl -X POST https://deflato.com/api/v1/compress   -H "Authorization: Bearer $DEFLATO_API_KEY"   -F "file=@photo.jpg"   -F "output_format=WEBP"   -F "quality=80"   --output photo.webp

Skalieren und Komprimieren

# Auf max 1920 px skalieren, nach AVIF konvertieren
curl -X POST https://deflato.com/api/v1/compress   -H "Authorization: Bearer $DEFLATO_API_KEY"   -F "file=@photo.jpg"   -F "output_format=AVIF"   -F "quality=70"   -F "max_dimension=1920"   --output photo.avif

HEIC nach JPEG

curl -X POST https://deflato.com/api/v1/compress   -H "Authorization: Bearer $DEFLATO_API_KEY"   -F "file=@IMG_1234.heic"   -F "output_format=JPEG"   -F "quality=85"   --output photo.jpg

API-Parameter-Referenz

Parameter Typ Standard Beschreibung
file File erforderlich Die Bilddatei (JPEG, PNG, WebP, AVIF, HEIC, TIFF oder PDF)
output_format String Wie Eingabe Ausgabeformat: JPEG, WEBP oder AVIF
quality Integer 80 Komprimierungsqualität (1–100). Niedriger = kleinere Datei, mehr Artefakte
max_dimension Integer 0 (keine Skalierung) Maximale Breite oder Höhe in Pixeln. Proportional skaliert
strip_exif Boolean true EXIF/Metadaten aus der Ausgabe entfernen

Python-SDK

pip install deflato

Grundlegende Nutzung

import deflato

client = deflato.Client(api_key="YOUR_API_KEY")

result = client.compress(
    "photo.jpg",
    output_format="WEBP",
    quality=80,
    max_dimension=1920
)
result.save("photo.webp")

print(f"Original: {result.original_size / 1024:.0f} KB")
print(f"Komprimiert: {result.compressed_size / 1024:.0f} KB")
print(f"Einsparung: {result.savings_percent:.1f}%")

Stapelverarbeitung

import deflato
from pathlib import Path

client = deflato.Client(api_key="YOUR_API_KEY")

input_dir = Path("./images")
output_dir = Path("./optimized")
output_dir.mkdir(exist_ok=True)

for image_path in input_dir.glob("*.jpg"):
    result = client.compress(
        str(image_path),
        output_format="WEBP",
        quality=80
    )
    result.save(output_dir / f"{image_path.stem}.webp")
    print(f"{image_path.name}: {result.savings_percent:.1f}% gespart")

Verwendung mit Django

import deflato
from django.core.files.base import ContentFile

client = deflato.Client(api_key=settings.DEFLATO_API_KEY)

def optimize_upload(instance, **kwargs):
    if instance.image:
        result = client.compress(
            instance.image.path,
            output_format="WEBP",
            quality=80,
            max_dimension=1600
        )
        instance.image.save(
            f"{instance.image.name.rsplit('.', 1)[0]}.webp",
            ContentFile(result.content),
            save=False
        )

Node.js-SDK

npm install deflato

Grundlegende Nutzung

const Deflato = require('deflato');
const fs = require('fs');

const client = new Deflato({ apiKey: process.env.DEFLATO_API_KEY });

async function compressImage() {
  const result = await client.compress('./photo.jpg', {
    outputFormat: 'WEBP',
    quality: 80,
    maxDimension: 1920
  });

  fs.writeFileSync('./photo.webp', result.buffer);

  console.log(`Original: ${(result.originalSize / 1024).toFixed(0)} KB`);
  console.log(`Komprimiert: ${(result.compressedSize / 1024).toFixed(0)} KB`);
  console.log(`Einsparung: ${result.savingsPercent.toFixed(1)}%`);
}

compressImage();

Stapelverarbeitung mit Parallelitätskontrolle

const Deflato = require('deflato');
const fs = require('fs');
const path = require('path');
const { promisify } = require('util');
const glob = promisify(require('glob'));

const client = new Deflato({ apiKey: process.env.DEFLATO_API_KEY });

async function batchCompress(inputDir, outputDir, concurrency = 5) {
  const files = await glob(`${inputDir}/*.{jpg,png,jpeg}`);
  fs.mkdirSync(outputDir, { recursive: true });

  for (let i = 0; i < files.length; i += concurrency) {
    const batch = files.slice(i, i + concurrency);
    const results = await Promise.all(
      batch.map(async (file) => {
        const result = await client.compress(file, {
          outputFormat: 'WEBP',
          quality: 80
        });
        const outPath = path.join(
          outputDir,
          path.basename(file, path.extname(file)) + '.webp'
        );
        fs.writeFileSync(outPath, result.buffer);
        return { file: path.basename(file), savings: result.savingsPercent };
      })
    );
    results.forEach(r =>
      console.log(`${r.file}: ${r.savings.toFixed(1)}% gespart`)
    );
  }
}

batchCompress('./images', './optimized');

MCP-Server-Integration

Deflato bietet einen MCP-Server (Model Context Protocol), der KI-Assistenten direkte Bildkomprimierung ermöglicht.

{
  "mcpServers": {
    "deflato": {
      "command": "npx",
      "args": ["-y", "deflato-mcp-server"],
      "env": {
        "DEFLATO_API_KEY": "YOUR_API_KEY"
      }
    }
  }
}

Nach der Konfiguration kann Ihr KI-Assistent Deflato-Tools aufrufen, um Bilder zu komprimieren, konvertieren und skalieren.

Fehlerbehandlung

Standard-HTTP-Statuscodes:

  • 200 — Erfolg. Der Response-Body enthält das komprimierte Bild.
  • 400 — Ungültige Anfrage (falsche Parameter).
  • 401 — Nicht autorisiert (API-Key fehlt oder ungültig).
  • 413 — Datei zu groß.
  • 429 — Rate-Limit erreicht. Mit exponentiellem Backoff erneut versuchen.
  • 500 — Serverfehler. Erneut versuchen.
import deflato

client = deflato.Client(api_key="YOUR_API_KEY")

try:
    result = client.compress("photo.jpg", output_format="WEBP", quality=80)
    result.save("photo.webp")
except deflato.AuthenticationError:
    print("Ungültiger API-Key")
except deflato.RateLimitError as e:
    print(f"Rate-Limit. Erneuter Versuch nach {e.retry_after} Sekunden")
except deflato.FileTooLargeError:
    print("Datei überschreitet die maximale Upload-Größe")
except deflato.APIError as e:
    print(f"API-Fehler: {e.message}")

Rate-Limits und Preise

Plan API-Komprimierungen / Monat Max. Dateigröße Rate-Limit
Free 100 10 MB 10 Req/Min
Pro 10.000 50 MB 60 Req/Min
Team 100.000 100 MB 300 Req/Min
Enterprise Individuell Individuell Individuell 
curl https://deflato.com/api/v1/usage   -H "Authorization: Bearer $DEFLATO_API_KEY"
{
  "plan": "pro",
  "compressions_used": 1847,
  "compressions_limit": 10000,
  "period_ends": "2026-04-01T00:00:00Z"
}

Best Practices

  • Ergebnisse cachen — Dasselbe Bild nicht zweimal komprimieren.
  • Umgebungsvariablen für den API-Key verwenden. Niemals in Versionskontrolle committen.
  • Retry-Logik mit exponentiellem Backoff für 429- und 500-Antworten implementieren.
  • Timeout setzen — 30 Sekunden als vernünftiger Wert.
  • Beim Upload komprimieren, nicht bei der Anfrage — Bilder beim ersten Upload optimieren.
  • Nutzung überwachen — /usage-Endpoint nutzen.

Fazit

Die Deflato-API verwandelt Bildoptimierung von einer manuellen Aufgabe in einen automatisierten Pipeline-Schritt. Ob Nutzer-Uploads in einer Web-App, statische Websites oder KI-Workflows via MCP — die API bietet eine einheitliche Schnittstelle. Beginnen Sie mit den cURL-Beispielen und integrieren Sie dann das Python- oder Node.js-SDK für den Produktiveinsatz.

Try Deflato — compress your images for free

Reduce file sizes by up to 90% with no visible quality loss. Supports JPEG, PNG, WebP, AVIF, PDF, and Office documents.

Compress Images Now