Wie man bei Proxys spart: 8 funktionierende Methoden

Realistische Wege, um Proxy-Kosten um 30-70% zu senken, ohne Qualität einzubüßen: Traffic-Optimierung, Mengenrabatte, Wechsel zum richtigen Typ, Timing des Abonnements.

1. Unnötige Ressourcen blockieren (60–80% Ersparnis)

Der größte Hebel. Auf einer durchschnittlichen Website sind ~70% der Bandbreite Bilder, CSS, Schriften und Video. Wenn du nur Text oder strukturierte Daten scrapest, blockiere all das:

// Puppeteer
await page.setRequestInterception(true);
page.on('request', req => {
  if (['image', 'stylesheet', 'font', 'media'].includes(req.resourceType())) {
    req.abort();
  } else {
    req.continue();
  }
});

Ersparnis: 10 GB/Tag → 2–3 GB/Tag. Bei residential zu $2/GB sind das $240/mo saved.

2. Zum richtigen Proxy-Typ wechseln

Viele Teams zahlen zu viel für residential, wo datacenter reichen würde:

• API-Integrationen ohne anti-bot — datacenter ($0.5/GB), ~5× günstiger
• Scraping öffentlicher JSON-Endpunkte — datacenter
• Interne Tools — datacenter

Leitfaden zu Proxy-Typen: lesen

3. Mengen- und Jahresrabatte

Fast alle Anbieter geben einen Mengenrabatt:

• SOAX — 15–20% Rabatt ab 100 GB
• Decodo — Jahresabo -25%
• Bright Data — individuelle Pläne ab $1000/mo mit 30%+ Rabatt

Wenn du 6+ Monate Arbeit einplanst, wechsle zu einem Jahresabo. 25% Ersparnis.

4. Lokales Caching

Frag nicht dasselbe zweimal ab. Ein einfacher Redis-Cache mit 1–7 Tagen TTL spart bei typischen scraping-Aufgaben 30–50% der Requests:

import redis
import hashlib

cache = redis.Redis()

def fetch_cached(url, ttl=86400):
    key = 'http:' + hashlib.md5(url.encode()).hexdigest()
    cached = cache.get(key)
    if cached:
        return cached.decode()
    data = fetch_via_proxy(url)
    cache.setex(key, ttl, data)
    return data

5. Immer gzip aktivieren

Ein Header spart 60–80% der Bandbreite:

headers = {'Accept-Encoding': 'gzip, deflate, br'}
requests.get(url, headers=headers, ...)

Die meisten modernen Bibliotheken dekodieren gzip-Antworten automatisch. Manche Anbieter messen den Stream nach der Dekompression — lies die ToS genau.

6. Ein eigenes rate limit statt Retries bei 429

Wenn du weißt, dass das Ziel ein Limit von ~5 req/sec hat, begrenze deinen Client auf 4 req/sec, statt 429 abzufangen und es erneut zu versuchen. Jeder Retry ist eine komplett verschwendete Runde Bandbreite.

import asyncio
sem = asyncio.Semaphore(4)

async def fetch(url):
    async with sem:
        await asyncio.sleep(0.25)  # max 4 req/sec
        return await aiohttp_fetch(url)

7. Pay-as-you-go vs. Abonnement

Wenn der Verbrauch unregelmäßig ist (ein großer Research-Lauf pro Monat), ist pay-as-you-go günstiger:

• Decodo PAYG: $4/GB
• Decodo monatlich 50 GB: $200/mo = $4/GB, wenn du alles nutzt. Nutzt du 20 GB, sind es effektiv $10/GB.

Einfache Regel: wenn du weniger als 80% des monatlichen Volumens nutzt, wechsle zu pay-as-you-go.

8. Gemischte Strategie: verschiedene Anbieter für verschiedene Aufgaben

Nutze nicht einen Dienst für alles. Ein realistisches Team hat 3–4 Accounts:

• Webshare ($0.65/GB datacenter) — für Backend-Integrationen
• Decodo ($2.20/GB residential) — für alltägliches scraping
• Bright Data ($5/GB residential) — für anti-bot-geschützte Ziele (DataDome)
• iProxy.online ($25/port mobile) — für Multi-Accounting

Eine gemischte Strategie spart 40–60% gegenüber einer Einheitslösung.

Beim Sparen an Proxys geht es nicht darum, das Billigste zu wählen — sondern die richtigen Typen für die richtigen Aufgaben zu nutzen. Oft zahlt sich der Aufpreis für hochwertiges residential durch eingesparte Retry-Logik und Time-to-Completion aus.