Skip to content

Python-Requests-Bibliothek: Vollständiger Leitfaden zu HTTP-Requests in Python

Soren Atelier
Name
Soren Atelier

Updated on

HTTP-Requests in Python mit dem eingebauten urllib-Modul zu erstellen, ist berüchtigt für seine Komplexität und Ausführlichkeit. Du musst Parameter manuell encodieren, Response-Objekte über mehrere Methodenaufrufe handhaben und Dutzende Zeilen Boilerplate-Code schreiben, nur um eine einfache API-Anfrage zu senden. Diese Komplexität verlangsamt die Entwicklung und macht deinen Code schwerer wartbar.

Die Python requests library beseitigt diese Frustration, indem sie eine elegante, menschenfreundliche API für HTTP-Kommunikation bereitstellt. Egal, ob du REST APIs konsumierst, Websites scrapest, Dateien hochlädst oder Automatisierungsskripte baust – die requests library macht HTTP-Operationen mit nur wenigen Zeilen Code intuitiv und unkompliziert.

In diesem umfassenden Leitfaden lernst du alles – von grundlegenden GET- und POST-Requests bis hin zu fortgeschrittenen Features wie Authentifizierung, Sessions, Fehlerbehandlung und praxisnahen Mustern zur API-Integration.

📚

    Installation der Python Requests Library

    Die requests library ist nicht Teil der Python-Standardbibliothek, daher musst du sie separat mit pip installieren:

    pip install requests

    Für conda-Nutzer:

    conda install requests

    Nach der Installation kannst du sie in deinen Python-Skripten importieren:

    import requests

    Um die Installation zu prüfen und die Version zu überprüfen:

    import requests
print(requests.__version__)

    GET-Requests mit Python Requests ausführen

    GET-Requests sind die häufigste HTTP-Methode und werden verwendet, um Daten von Servern abzurufen. Die requests library macht GET-Requests extrem einfach.

    Einfacher GET-Request

    So führst du einen einfachen GET-Request aus:

    import requests
 
response = requests.get('https://api.github.com')
print(response.status_code)  # 200
print(response.text)  # Response-Body als String

    GET-Request mit Query-Parametern

    Anstatt URLs mit Query-Strings manuell zusammenzubauen, verwende den Parameter params:

    import requests
 
# Method 1: Using params dictionary
params = {
    'q': 'python requests',
    'sort': 'stars',
    'order': 'desc'
}
response = requests.get('https://api.github.com/search/repositories', params=params)
 
# The URL is automatically constructed:
# https://api.github.com/search/repositories?q=python+requests&sort=stars&order=desc
 
print(response.url)  # View the constructed URL
data = response.json()  # Parse JSON response

    GET-Request mit eigenen Headers

    Viele APIs verlangen eigene Headers für Authentifizierung oder Content Negotiation:

    import requests
 
headers = {
    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
    'Accept': 'application/json',
    'Accept-Language': 'en-US,en;q=0.9'
}
 
response = requests.get('https://api.example.com/data', headers=headers)
print(response.json())

    POST-Requests in Python ausführen

    POST-Requests senden Daten an einen Server und werden häufig für Formular-Submits und API-Operationen verwendet.

    POST-Request mit Formulardaten

    Um form-encodierte Daten zu senden (wie bei HTML-Formularen):

    import requests
 
# Send form data
data = {
    'username': 'john_doe',
    'password': 'secret123',
    'remember_me': True
}
 
response = requests.post('https://example.com/login', data=data)
print(response.status_code)

    POST-Request mit JSON-Payload

    Moderne REST APIs erwarten typischerweise JSON-Payloads. Die requests library übernimmt die JSON-Serialisierung automatisch:

    import requests
 
# Method 1: Using json parameter (recommended)
payload = {
    'name': 'New Project',
    'description': 'A test project',
    'tags': ['python', 'api']
}
 
response = requests.post('https://api.example.com/projects', json=payload)
 
# Method 2: Manual JSON encoding
import json
headers = {'Content-Type': 'application/json'}
response = requests.post(
    'https://api.example.com/projects',
    data=json.dumps(payload),
    headers=headers
)

    POST-Request mit Dateien

    Dateien lädst du über den Parameter files hoch:

    import requests
 
# Upload a single file
files = {'file': open('report.pdf', 'rb')}
response = requests.post('https://example.com/upload', files=files)
 
# Upload multiple files
files = {
    'file1': open('document.pdf', 'rb'),
    'file2': open('image.jpg', 'rb')
}
response = requests.post('https://example.com/upload', files=files)
 
# Upload file with additional form data
files = {'file': open('data.csv', 'rb')}
data = {'description': 'Monthly report', 'category': 'finance'}
response = requests.post('https://example.com/upload', files=files, data=data)

    Weitere HTTP-Methoden: PUT, PATCH, DELETE

    Die requests library unterstützt alle Standard-HTTP-Methoden:

    import requests
 
# PUT - Replace entire resource
data = {'name': 'Updated Name', 'status': 'active'}
response = requests.put('https://api.example.com/users/123', json=data)
 
# PATCH - Partially update resource
data = {'status': 'inactive'}
response = requests.patch('https://api.example.com/users/123', json=data)
 
# DELETE - Remove resource
response = requests.delete('https://api.example.com/users/123')
print(response.status_code)  # 204 No Content
 
# HEAD - Get headers only (no response body)
response = requests.head('https://example.com')
print(response.headers)
 
# OPTIONS - Get supported methods
response = requests.options('https://api.example.com/users')
print(response.headers.get('Allow'))

    Das Response-Objekt verstehen

    Das Response-Objekt enthält alle Informationen über die Antwort des Servers:

    import requests
 
response = requests.get('https://api.github.com/users/github')
 
# Status code
print(response.status_code)  # 200, 404, 500, etc.
 
# Response body as string
print(response.text)
 
# Response body as JSON (for JSON APIs)
data = response.json()
print(data['login'])
 
# Raw binary content (for images, files)
image_data = response.content
with open('profile.jpg', 'wb') as f:
    f.write(image_data)
 
# Response headers
print(response.headers)
print(response.headers['Content-Type'])
 
# Encoding
print(response.encoding)  # 'utf-8'
 
# Request information
print(response.request.headers)
print(response.request.url)
 
# Check if request was successful
if response.ok:  # True if status_code < 400
    print("Success!")

    Mit Request-Headers arbeiten

    Headers transportieren wichtige Metadaten über den Request:

    Eigene Headers setzen

    import requests
 
headers = {
    'User-Agent': 'MyApp/1.0',
    'Accept': 'application/json',
    'Accept-Encoding': 'gzip, deflate',
    'Connection': 'keep-alive',
    'Custom-Header': 'custom-value'
}
 
response = requests.get('https://api.example.com', headers=headers)

    Response-Headers auslesen

    import requests
 
response = requests.get('https://api.github.com')
 
# Dictionary-like access
print(response.headers['Content-Type'])
print(response.headers.get('X-RateLimit-Remaining'))
 
# Case-insensitive access
print(response.headers['content-type'])  # Works!
 
# Iterate all headers
for key, value in response.headers.items():
    print(f"{key}: {value}")

    Authentifizierung mit Python Requests

    Die requests library unterstützt mehrere Authentifizierungsmechanismen:

    Basic Authentication

    import requests
from requests.auth import HTTPBasicAuth
 
# Method 1: Using auth parameter (recommended)
response = requests.get(
    'https://api.example.com/protected',
    auth=('username', 'password')
)
 
# Method 2: Explicit HTTPBasicAuth
response = requests.get(
    'https://api.example.com/protected',
    auth=HTTPBasicAuth('username', 'password')
)
 
# Method 3: Manual header (not recommended)
import base64
credentials = base64.b64encode(b'username:password').decode('utf-8')
headers = {'Authorization': f'Basic {credentials}'}
response = requests.get('https://api.example.com/protected', headers=headers)

    Bearer-Token-Authentifizierung

    Gängig für JWT-Tokens und OAuth 2.0:

    import requests
 
token = 'your_access_token_here'
headers = {'Authorization': f'Bearer {token}'}
 
response = requests.get('https://api.example.com/user', headers=headers)

    API-Key-Authentifizierung

    import requests
 
# Method 1: Query parameter
params = {'api_key': 'your_api_key_here'}
response = requests.get('https://api.example.com/data', params=params)
 
# Method 2: Custom header
headers = {'X-API-Key': 'your_api_key_here'}
response = requests.get('https://api.example.com/data', headers=headers)

    OAuth 2.0-Authentifizierung

    Für OAuth 2.0 verwende die Library requests-oauthlib:

    from requests_oauthlib import OAuth2Session
 
client_id = 'your_client_id'
client_secret = 'your_client_secret'
token_url = 'https://oauth.example.com/token'
 
oauth = OAuth2Session(client_id)
token = oauth.fetch_token(token_url, client_secret=client_secret)
 
# Make authenticated requests
response = oauth.get('https://api.example.com/protected')

    Sessions für persistente Verbindungen

    Sessions behalten Cookies, Connection Pooling und Konfiguration über mehrere Requests hinweg bei:

    import requests
 
# Create a session
session = requests.Session()
 
# Set headers for all requests in this session
session.headers.update({
    'User-Agent': 'MyApp/1.0',
    'Accept': 'application/json'
})
 
# Login and session maintains cookies
login_data = {'username': 'john', 'password': 'secret'}
session.post('https://example.com/login', data=login_data)
 
# Subsequent requests use the session cookies
response1 = session.get('https://example.com/dashboard')
response2 = session.get('https://example.com/profile')
 
# Close the session
session.close()

    Session mit Authentifizierung

    import requests
 
session = requests.Session()
session.auth = ('username', 'password')
 
# All requests in this session use the authentication
response1 = session.get('https://api.example.com/users')
response2 = session.get('https://api.example.com/posts')

    Session-Context-Manager

    import requests
 
with requests.Session() as session:
    session.headers.update({'Authorization': 'Bearer token123'})
 
    response1 = session.get('https://api.example.com/data')
    response2 = session.post('https://api.example.com/data', json={'key': 'value'})
 
# Session automatically closed after with block

    Timeout- und Retry-Strategien

    Setze immer Timeouts, damit Requests nicht unbegrenzt hängen bleiben:

    Timeouts setzen

    import requests
 
# Single timeout value (applies to both connect and read)
response = requests.get('https://api.example.com', timeout=5)
 
# Separate connect and read timeouts
response = requests.get('https://api.example.com', timeout=(3, 10))
# 3 seconds to establish connection, 10 seconds to read response
 
# No timeout (dangerous - may hang forever)
response = requests.get('https://api.example.com', timeout=None)

    Retry-Logik implementieren

    import requests
from requests.adapters import HTTPAdapter
from requests.packages.urllib3.util.retry import Retry
 
# Configure retry strategy
retry_strategy = Retry(
    total=3,  # Total number of retries
    backoff_factor=1,  # Wait 1, 2, 4 seconds between retries
    status_forcelist=[429, 500, 502, 503, 504],  # Retry on these status codes
    allowed_methods=["HEAD", "GET", "OPTIONS", "POST"]
)
 
adapter = HTTPAdapter(max_retries=retry_strategy)
session = requests.Session()
session.mount("http://", adapter)
session.mount("https://", adapter)
 
# Requests will automatically retry on failure
response = session.get('https://api.example.com/data')

    Fehlerbehandlung in Python Requests

    Robuste Fehlerbehandlung ist entscheidend für Production-Anwendungen:

    Häufige Exceptions behandeln

    import requests
from requests.exceptions import (
    ConnectionError,
    Timeout,
    HTTPError,
    RequestException
)
 
try:
    response = requests.get('https://api.example.com/data', timeout=5)
    response.raise_for_status()  # Raises HTTPError for 4xx/5xx status codes
    data = response.json()
 
except ConnectionError:
    print("Failed to connect to the server")
 
except Timeout:
    print("Request timed out")
 
except HTTPError as e:
    print(f"HTTP error occurred: {e}")
    print(f"Status code: {e.response.status_code}")
 
except RequestException as e:
    # Catches all requests exceptions
    print(f"An error occurred: {e}")
 
except ValueError:
    # JSON decoding error
    print("Invalid JSON response")

    Status Codes prüfen

    import requests
 
response = requests.get('https://api.example.com/data')
 
# Method 1: Manual check
if response.status_code == 200:
    data = response.json()
elif response.status_code == 404:
    print("Resource not found")
elif response.status_code >= 500:
    print("Server error")
 
# Method 2: Using raise_for_status()
try:
    response.raise_for_status()
    data = response.json()
except requests.exceptions.HTTPError as e:
    if response.status_code == 404:
        print("Resource not found")
    elif response.status_code == 401:
        print("Authentication required")
    else:
        print(f"HTTP error: {e}")
 
# Method 3: Using response.ok
if response.ok:  # True if status_code < 400
    data = response.json()
else:
    print(f"Request failed with status {response.status_code}")

    SSL-Verifizierung und Zertifikate

    Standardmäßig verifiziert requests SSL-Zertifikate:

    import requests
 
# Default behavior - verify SSL certificate
response = requests.get('https://api.example.com')
 
# Disable SSL verification (not recommended for production)
response = requests.get('https://example.com', verify=False)
 
# Suppress the InsecureRequestWarning
import urllib3
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
response = requests.get('https://example.com', verify=False)
 
# Use custom CA bundle
response = requests.get('https://example.com', verify='/path/to/ca_bundle.crt')
 
# Client-side certificates
response = requests.get(
    'https://example.com',
    cert=('/path/to/client.crt', '/path/to/client.key')
)

    Proxies mit Python Requests verwenden

    Proxy-Server für Requests konfigurieren:

    import requests
 
# HTTP and HTTPS proxies
proxies = {
    'http': 'http://10.10.1.10:3128',
    'https': 'http://10.10.1.10:1080',
}
 
response = requests.get('https://api.example.com', proxies=proxies)
 
# SOCKS proxy (requires requests[socks])
proxies = {
    'http': 'socks5://user:pass@host:port',
    'https': 'socks5://user:pass@host:port'
}
 
# Use environment variables
# Set HTTP_PROXY and HTTPS_PROXY environment variables
response = requests.get('https://api.example.com')  # Automatically uses env proxies
 
# Disable proxies
response = requests.get('https://api.example.com', proxies={'http': None, 'https': None})

    Vergleich von Python HTTP Libraries

    So schneidet die requests library im Vergleich zu Alternativen ab:

    Featurerequestsurllibhttpxaiohttp
    BenutzerfreundlichkeitExzellent (Pythonic API)Schlecht (ausführlich)ExzellentGut
    Async-SupportNeinNeinJaJa
    HTTP/2-SupportNeinNeinJaNein
    Session-ManagementIntegriertManuellIntegriertIntegriert
    JSON-HandlingAutomatischManuellAutomatischAutomatisch
    Connection PoolingJaNeinJaJa
    StandardbibliothekNein (pip install)JaNein (pip install)Nein (pip install)
    DokumentationExzellentGutExzellentGut
    PerformanceGutMittelmäßigExzellentExzellent (async)
    SSL/TLSVoller SupportVoller SupportVoller SupportVoller Support
    Am besten fürSynchrones HTTP, allgemeine NutzungEinfache Skripte, keine DependenciesModernes sync/async HTTPHigh-Performance async

    Wann du was verwenden solltest:

    • requests: Standardwahl für die meisten synchronen HTTP-Operationen. Ideal für Web Scraping, API-Konsum und allgemeine HTTP-Aufgaben.
    • urllib: Nur wenn du keine externen Pakete installieren kannst (Anforderung: Standardbibliothek).
    • httpx: Wenn du HTTP/2-Support brauchst oder eine moderne, requests-kompatible API mit Async-Fähigkeiten möchtest.
    • aiohttp: Für performante asynchrone Anwendungen mit vielen parallelen Requests.

    Rate Limiting und respektvolles Scraping

    Beim Scraping von Websites oder beim Aufruf von APIs solltest du Rate Limiting implementieren:

    import requests
import time
from datetime import datetime
 
class RateLimitedSession:
    def __init__(self, requests_per_second=1):
        self.session = requests.Session()
        self.min_interval = 1.0 / requests_per_second
        self.last_request_time = 0
 
    def get(self, url, **kwargs):
        # Wait if necessary
        elapsed = time.time() - self.last_request_time
        if elapsed < self.min_interval:
            time.sleep(self.min_interval - elapsed)
 
        # Make request
        response = self.session.get(url, **kwargs)
        self.last_request_time = time.time()
        return response
 
# Use rate-limited session
session = RateLimitedSession(requests_per_second=2)  # 2 requests per second
 
urls = ['https://api.example.com/item/1', 'https://api.example.com/item/2']
for url in urls:
    response = session.get(url)
    print(f"{datetime.now()}: {response.status_code}")

    robots.txt respektieren

    import requests
from urllib.robotparser import RobotFileParser
 
def can_fetch(url, user_agent='MyBot'):
    """Check if URL can be scraped according to robots.txt"""
    rp = RobotFileParser()
    robots_url = f"{url.split('/')[0]}//{url.split('/')[2]}/robots.txt"
    rp.set_url(robots_url)
    rp.read()
    return rp.can_fetch(user_agent, url)
 
url = 'https://example.com/page'
if can_fetch(url):
    response = requests.get(url)
else:
    print("Scraping not allowed by robots.txt")

    Praxisbeispiele und Use Cases

    Beispiel 1: Eine REST API konsumieren

    import requests
 
class GitHubAPI:
    def __init__(self, token=None):
        self.base_url = 'https://api.github.com'
        self.session = requests.Session()
        if token:
            self.session.headers.update({'Authorization': f'token {token}'})
 
    def get_user(self, username):
        """Get user information"""
        response = self.session.get(f'{self.base_url}/users/{username}')
        response.raise_for_status()
        return response.json()
 
    def search_repositories(self, query, sort='stars', limit=10):
        """Search repositories"""
        params = {'q': query, 'sort': sort, 'per_page': limit}
        response = self.session.get(f'{self.base_url}/search/repositories', params=params)
        response.raise_for_status()
        return response.json()['items']
 
    def create_issue(self, owner, repo, title, body):
        """Create an issue in a repository"""
        url = f'{self.base_url}/repos/{owner}/{repo}/issues'
        data = {'title': title, 'body': body}
        response = self.session.post(url, json=data)
        response.raise_for_status()
        return response.json()
 
# Usage
api = GitHubAPI(token='your_github_token')
user = api.get_user('torvalds')
print(f"Name: {user['name']}, Followers: {user['followers']}")
 
repos = api.search_repositories('python requests', limit=5)
for repo in repos:
    print(f"{repo['full_name']}: {repo['stargazers_count']} stars")

    Beispiel 2: Dateien mit Fortschrittsanzeige herunterladen

    import requests
from tqdm import tqdm
 
def download_file(url, filename):
    """Download file with progress bar"""
    response = requests.get(url, stream=True)
    response.raise_for_status()
 
    total_size = int(response.headers.get('content-length', 0))
 
    with open(filename, 'wb') as f, tqdm(
        desc=filename,
        total=total_size,
        unit='B',
        unit_scale=True,
        unit_divisor=1024,
    ) as progress_bar:
        for chunk in response.iter_content(chunk_size=8192):
            f.write(chunk)
            progress_bar.update(len(chunk))
 
# Download a file
download_file('https://example.com/large-file.zip', 'downloaded.zip')

    Beispiel 3: Web Scraping mit Fehlerbehandlung

    import requests
from bs4 import BeautifulSoup
import time
 
def scrape_articles(base_url, max_pages=5):
    """Scrape article titles from a news website"""
    session = requests.Session()
    session.headers.update({
        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
    })
 
    articles = []
 
    for page in range(1, max_pages + 1):
        try:
            url = f"{base_url}?page={page}"
            response = session.get(url, timeout=10)
            response.raise_for_status()
 
            soup = BeautifulSoup(response.content, 'html.parser')
            titles = soup.find_all('h2', class_='article-title')
 
            for title in titles:
                articles.append({
                    'title': title.text.strip(),
                    'url': title.find('a')['href'] if title.find('a') else None
                })
 
            print(f"Scraped page {page}: {len(titles)} articles")
            time.sleep(1)  # Rate limiting
 
        except requests.exceptions.RequestException as e:
            print(f"Error scraping page {page}: {e}")
            continue
 
    return articles
 
# Usage
articles = scrape_articles('https://news.example.com/articles', max_pages=3)
print(f"Total articles collected: {len(articles)}")

    Beispiel 4: API-Integration mit Pagination

    import requests
 
def fetch_all_items(api_url, headers=None):
    """Fetch all items from a paginated API"""
    items = []
    page = 1
 
    while True:
        try:
            params = {'page': page, 'per_page': 100}
            response = requests.get(api_url, params=params, headers=headers, timeout=10)
            response.raise_for_status()
 
            data = response.json()
 
            if not data:  # No more items
                break
 
            items.extend(data)
            print(f"Fetched page {page}: {len(data)} items")
 
            page += 1
 
            # Check for pagination in headers
            if 'Link' in response.headers:
                links = response.headers['Link']
                if 'rel="next"' not in links:
                    break
 
        except requests.exceptions.RequestException as e:
            print(f"Error fetching page {page}: {e}")
            break
 
    return items
 
# Usage
all_items = fetch_all_items('https://api.example.com/items')
print(f"Total items: {len(all_items)}")

    APIs in Jupyter mit RunCell testen

    Beim Entwickeln und Testen von API-Integrationen bietet RunCell (opens in a new tab) eine KI-gestützte Agent-Umgebung direkt in Jupyter-Notebooks. Statt HTTP-Requests und Responses manuell zu debuggen, kann dir der intelligente Agent von RunCell helfen:

    • API-Requests mit korrekter Authentifizierung automatisch zu erstellen und zu testen
    • Response-Parsing und Fehlerbehandlung in Echtzeit zu debuggen
    • Code-Snippets für gängige HTTP-Patterns zu generieren
    • API-Responses gegen erwartete Schemas zu validieren
    • Schnell über Data Transformations aus API-Responses zu iterieren

    Das ist besonders wertvoll bei komplexen APIs, die mehrere Authentifizierungsschritte, Pagination-Handling oder komplizierte Parsing-Logik erfordern. RunCell beschleunigt den Entwicklungsworkflow, indem es das ständige Hin und Her beim manuellen Testen von HTTP-Requests reduziert.

    FAQ

    Wofür wird die Python requests library verwendet?

    Die Python requests library wird verwendet, um HTTP-Requests an Webserver und APIs zu senden. Sie vereinfacht Aufgaben wie das Abrufen von Webseiten, das Konsumieren von REST APIs, das Senden von Formulardaten, das Hochladen von Dateien und das Handhaben von Authentifizierung. Sie ist die populärste HTTP-Bibliothek in Python – dank ihrer intuitiven API und ihres umfassenden Feature-Sets.

    Wie installiere ich die Python requests library?

    Installiere die requests library mit pip: pip install requests. Für conda-Umgebungen verwende conda install requests. Danach importierst du sie in deinem Python-Code mit import requests. Die Library ist nicht Teil der Python-Standardbibliothek, daher ist eine Installation erforderlich.

    Was ist der Unterschied zwischen requests.get() und requests.post()?

    requests.get() ruft Daten von einem Server ab, ohne etwas zu verändern, und wird typischerweise zum Laden von Webseiten oder API-Daten genutzt. requests.post() sendet Daten an den Server, um Ressourcen zu erstellen oder zu aktualisieren – häufig für Formular-Submits, Datei-Uploads oder API-Operationen, die den Serverzustand verändern. GET-Requests übergeben Parameter in der URL, während POST-Requests Daten im Request-Body senden.

    Wie behandle ich Fehler mit der Python requests library?

    Verwende try-except-Blöcke, um Request-Exceptions abzufangen: ConnectionError für Netzwerkprobleme, Timeout für langsame Antworten, HTTPError für 4xx/5xx-Statuscodes und RequestException als Catch-all. Rufe nach jedem Request response.raise_for_status() auf, um automatisch HTTPError für fehlgeschlagene Requests auszulösen. Setze immer Timeouts, damit Requests nicht unbegrenzt hängen bleiben.

    Wie sende ich JSON-Daten mit Python requests?

    Nutze den json-Parameter in requests: requests.post(url, json=data). Die Library serialisiert Python-Dictionaries automatisch zu JSON und setzt den Header Content-Type: application/json. Um JSON-Responses zu parsen, verwende response.json(), das den JSON-Response-Body in ein Python-Dictionary deserialisiert.

    Sollte ich requests oder urllib in Python verwenden?

    Verwende für die meisten HTTP-Operationen die requests library. Sie bietet eine sauberere API, automatisches JSON-Handling, integriertes Session-Management und bessere Fehlerbehandlung als urllib. Nutze urllib nur dann, wenn du keine externen Pakete installieren kannst und ausschließlich auf die Standardbibliothek angewiesen bist. Für moderne Anwendungen mit HTTP/2 oder Async-Support ist httpx eine gute Alternative.

    Wie füge ich Authentifizierung zu Python requests hinzu?

    Für Basic Authentication verwende requests.get(url, auth=('username', 'password')). Für Bearer Tokens (JWT, OAuth) fügst du einen Authorization-Header hinzu: headers = {'Authorization': f'Bearer {token}'}. Für API Keys kannst du sie entweder als Query-Parameter über das params-Dictionary oder als Custom Header wie 'X-API-Key' mitsenden. Sessions können Authentifizierung über mehrere Requests hinweg beibehalten.

    Was sind Sessions in Python requests und wann sollte ich sie verwenden?

    Sessions behalten Konfiguration (Headers, Cookies, Authentifizierung) über mehrere Requests an denselben Server bei. Verwende Sessions, wenn du mehrere Requests an eine API machst, wenn du Login-State über Cookies halten musst oder wenn du TCP-Verbindungen für bessere Performance wiederverwenden möchtest. Erstelle eine Session mit session = requests.Session() und verwende dann session.get() statt requests.get().

    Fazit

    Die Python requests library ist ein unverzichtbares Tool für HTTP-Kommunikation in Python. Ihre elegante API verwandelt komplexe HTTP-Operationen in einfachen, gut lesbaren Code. Von grundlegenden GET-Requests bis hin zu fortgeschrittenen Features wie Authentifizierung, Sessions, Datei-Uploads und Fehlerbehandlung bietet requests alles, was du für robuste HTTP-Interaktionen brauchst.

    Wenn du die Patterns und Best Practices aus diesem Guide beherrschst – Timeouts setzen, Retry-Logik implementieren, Fehler sauber behandeln und Rate Limits respektieren – baust du zuverlässige Anwendungen, die effektiv mit Webservices und APIs kommunizieren. Egal ob du REST APIs konsumierst, Websites scrapest oder Automatisierungstools entwickelst: Die requests library macht HTTP-Operationen unkompliziert und wartbar.

    📚