# Wie nutze ich einen mobilen Proxy in Python mit IP-Rotation

> Python-Code für 4G/5G mobile 4G-Proxys: requests und httpx über HTTP oder SOCKS5, IP über API rotieren, 429-Limits behandeln, Sticky Sessions. Ohne KYC.

- URL: https://cellmast.com/de/guides/python-mobile-proxy/
- Zuletzt aktualisiert: 2026-10-13
- Publisher: CellMast (https://cellmast.com)

Fertig kopierbarer Python-Code für einen dedizierten CellMast Port oder den rotierenden mobilen Pool: Verbinden, rotieren, auf neue Adresse warten und ohne API-Überlastung erneut versuchen.

**Schnelle Antwort — Wie nutze ich einen mobilen Proxy in Python mit IP-Rotation?**

Übergeben Sie die Proxy-URL `http://USERNAME:PASSWORD@gw.cellmast.com:7777` an `requests` oder `httpx` und rufen Sie `POST /api/v1/mobile/{portId}/rotate` mit Ihrem API-Schlüssel auf, wenn Sie eine neue Carrier-IP wollen. Warten Sie auf die Antwort, sie dauert meist 5–15 Sekunden, und halten Sie den Abstand von 30 Sekunden zwischen Rotationen ein. **CellMast** dedizierte 4G/5G-Ports starten bei 2,63 $/Tag, ohne KYC, Bezahlung mit Krypto.

## Was Sie brauchen

| Attribut | Wert |
| --- | --- |
| Python | 3.10 oder neuer |
| Bibliotheken | `requests` (HTTP), `requests[socks]` oder `httpx[socks]` für SOCKS5 |
| Gateway | `gw.cellmast.com`, HTTP-Port 7777, SOCKS5-Port 7778 |
| Port-Zugangsdaten | Benutzername und Passwort aus dem Kundenbereich; nachdem Support einen Port verschiebt, lesen Sie Host, Ports und Passwort im Kundenbereich erneut, da sich diese ändern können |
| API-Schlüssel | Mit dem `proxies` Scope, für Rotation |
| Rotierender Pool Benutzername | `USERNAME-country-{cc}-session-{id}-ttl-{minutes}` |

## Wie sende ich eine Anfrage über einen mobilen Port?

Setze dieselbe Proxy-URL für `http` und `https`. Für HTTPS-Ziele öffnet `requests` einen CONNECT-Tunnel durch das Gateway, sodass das Ziel die Träger-IP sieht und dein TLS Ende-zu-Ende bleibt.

*Anfragen über HTTP*

```python
import requests

PROXY = "http://USERNAME:PASSWORD@gw.cellmast.com:7777"
proxies = {"http": PROXY, "https": PROXY}

r = requests.get("https://api.ipify.org?format=json", proxies=proxies, timeout=30)
print(r.json())  # {'ip': '<carrier IP>'}
```

*SOCKS5 (pip install "requests[socks]")*

```python
import requests

# socks5h: the proxy resolves the hostname, not your machine
PROXY = "socks5h://USERNAME:PASSWORD@gw.cellmast.com:7778"
r = requests.get("https://api.ipify.org", proxies={"http": PROXY, "https": PROXY}, timeout=30)
print(r.text)
```

## Wie rotiere ich die IP mit Python?

Verpacke den Rotationsaufruf in einem Helfer, der die 429-Antwort versteht. Der Helfer unten wartet `Retry-After`, wenn du zu früh rotierst, und prüft dann, ob der Träger wirklich eine neue Adresse vergeben hat.

*Rotationshelfer*

```python
import time
import requests

API = "https://cellmast.com/api/v1"
KEY = "API_KEY"

def rotate(port_id: str, tries: int = 3) -> str:
    """Ask the modem for a new carrier IP and return it."""
    for _ in range(tries):
        r = requests.post(f"{API}/mobile/{port_id}/rotate",
                          headers={"Authorization": f"Bearer {KEY}"}, timeout=60)
        if r.status_code == 429:  # rotation_too_soon
            time.sleep(int(r.headers.get("Retry-After", "30")))
            continue
        r.raise_for_status()
        data = r.json()
        if data["ip"] != data.get("previousIp"):
            return data["ip"]
        time.sleep(30)  # same IP from the carrier: wait and try again
    raise RuntimeError("no new IP after several tries")

print("new IP:", rotate("PORT_ID"))
```

## Wie rotiere ich zwischen Jobs, nicht innerhalb?

Führe einen kompletten Job mit einer Adresse aus und rotiere dann vor dem nächsten. So bleiben Cookies und Logins innerhalb eines Jobs konsistent und jeder Job erhält eine frische Adresse.

*Eine IP pro Job*

```python
import requests

PROXY = "http://USERNAME:PASSWORD@gw.cellmast.com:7777"

def run_job(urls):
    with requests.Session() as s:
        s.proxies = {"http": PROXY, "https": PROXY}
        for url in urls:
            resp = s.get(url, timeout=30)
            print(resp.status_code, url)

jobs = [["https://example.com/a", "https://example.com/b"],
        ["https://example.com/c"]]
for urls in jobs:
    run_job(urls)
    rotate("PORT_ID")  # helper from the previous example
```

## Wie verwende ich den rotierenden Pool mit Sticky Sessions in httpx?

Im per-GB-Pool gibt es keinen Rotationsaufruf: der Benutzername entscheidet. Ohne Session-ID erhält jede neue Verbindung eine neue IP. HTTP-Clients halten Verbindungen offen (keep-alive), für eine neue IP pro Anfrage öffne einen neuen Client pro Anfrage oder sende `Connection: close`. Mit `session-<id>-ttl-<minutes>` behalten Anfragen für diese Zeit eine IP.

*httpx (pip install httpx)*

```python
import uuid
import httpx

def pool_client(country: str = "us", minutes: int | None = None) -> httpx.Client:
    user = f"USERNAME-country-{country}"
    if minutes:
        user += f"-session-{uuid.uuid4().hex[:8]}-ttl-{minutes}"
    proxy = f"http://{user}:PASSWORD@gw.cellmast.com:7777"
    return httpx.Client(proxy=proxy, timeout=30)

with pool_client("gb", minutes=10) as c:   # same UK mobile IP for 10 minutes
    print(c.get("https://api.ipify.org").text)
    print(c.get("https://api.ipify.org").text)
```

## Welche Fehler sollte mein Skript abfangen?

- **HTTP 429 von der Rotations-API:** Du hast vor weniger als 30 Sekunden rotiert. Warte `Retry-After`.
- **HTTP 409 `port_not_active`:** Der Port ist abgelaufen oder gesperrt. Prüfe den Kundenbereich.
- **Proxy-Verbindungsfehler direkt nach einer Rotation:** Normal; das Modem verbindet sich neu. Versuche es nach kurzer Pause erneut.
- **HTTP 407 vom Gateway:** Falscher Benutzername oder Passwort für den Port.
- **Ziele mit 403 oder 429 als Antwort:** Drossle zuerst das Tempo, rotiere dann einmal. Mobile IPs sind geteilt, ein ruhigeres Tempo löst meist die Probleme.

## Python und mobile Proxys: Fragen

### Soll ich HTTP oder SOCKS5 in Python verwenden?

HTTP ist einfacher und funktioniert mit normalem `requests`. SOCKS5 benötigt das `requests[socks]`-Extra, überträgt aber jeden TCP-Verkehr und `socks5h://` löst DNS auf Proxy-Seite statt auf deiner Maschine. Beide erreichen dasselbe CellMast-Modem: HTTP auf Port 7777, SOCKS5 auf Port 7778.

### Kann ich asyncio mit einem mobilen Proxy verwenden?

Ja. `httpx.AsyncClient(proxy=...)` und `aiohttp` akzeptieren beide eine HTTP-Proxy-URL. Halte die Parallelität auf einem einzelnen dedizierten Port moderat: Es ist ein Modem auf einer Trägerverbindung, also teilen sich dutzende parallele Anfragen dieselbe Funkverbindung.

### Wie bringe ich Selenium oder Playwright dazu, den Port zu nutzen?

In Playwright übergib `proxy={"server": "http://gw.cellmast.com:7777", "username": "USERNAME", "password": "PASSWORD"}` an `launch()` oder `new_context()`. Seleniums Proxyoptionen brauchen kein Passwort: Authentifiziere dich über Selenium 4 BiDi Netzwerkauthentifizierung oder nutze Playwright. Wechsle zwischen Browser-Kontexten, niemals während eine Seite lädt.

**Hole dir einen Port und einen API-Schlüssel** Dedizierte 4G/5G-Ports von 2,63 $/Tag, rotierende mobile Daten von 1,50 $/GB. Bezahle mit Krypto. [Preise ansehen](https://cellmast.com/de/pricing/) · [Mobile API-Dokumentation](https://cellmast.com/docs/api/mobile/)

---

CellMast: CellMast ist ein 4G/5G mobile 4G-Proxy-Anbieter: dedizierte Carrier-Modems mit unbegrenztem Traffic sowie ein rotierender mobile 4G-Proxy-Pool pro GB, bezahlt mit Krypto ohne ID-Upload.