# Python requests: HTTP-Anfragen mit Python senden

Python `requests` ist eine beliebte Bibliothek, mit der Sie HTTP-Anfragen senden und die Antworten überprüfen können. Auch wenn `.get()` die wichtigste Methode des Moduls ist, gibt es zahlreiche weitere Optionen.

## Was ist Python `requests`?

Python `requests` ist ein Standard, der es Ihnen ermöglicht, innerhalb der [Programmiersprache](https://www.ionos.de/digitalguide/websites/web-entwicklung/welche-programmiersprache-lernen/) **HTTP-Anfragen zu senden**. Grundlage dafür ist eine übersichtliche und effektive Programmschnittstelle, die die Einbindung von Drittanbieter-Features besonders einfach macht. Die Python `requests`-Bibliothek stellt verschiedene Tools zur Verfügung, mit denen Sie HTTP-Anfragen senden und die entsprechenden Antworten erhalten können. Auch wenn das Python `requests`-Module weit verbreitet und sehr empfehlenswert ist, **gehört es nicht zur Standardinstallation** von Python.

## Installation und Start der Bibliothek Python `requests`

Bevor Sie Python `requests` installieren, ist es empfehlenswert, zunächst eine [virtuelle Maschine](https://www.ionos.de/digitalguide/server/knowhow/virtuelle-maschinen/) aufzusetzen, in der Sie die Bibliothek bedenkenlos ausprobieren können. Für die Installation nutzen Sie dann `pip`. So sieht der Code aus:

```bash
$ python -m pip install requests
```

Um die Bibliothek nach der erfolgreichen Installation zu verwenden, benötigen Sie diesen Code:

```python
import requests
```

## Funktionsweise, Syntax und Methoden

Wie andere vergleichbare Tools sendet auch Python `requests` eine HTTP-Anfrage, die dann bei erfolgreicher Übermittlung eine Antwort erhält. Bei dieser Antwort handelt es sich um ein Objekt, in dem alle wichtigen Informationen wie **Inhalt, Codierung und Status** enthalten sind. Die Syntax für eine solche Anfrage sieht immer folgendermaßen aus:

```python
requests.methode(url, **kwargs)
```

Hinweis `**kwargs` steht für optionale Methoden, die Sie an Methoden wie `headers`, `files` oder `cookies` übergeben können.

Auch wenn `.get()` die Funktion ist, die Sie am häufigsten verwenden werden, stellt Ihnen Python requests noch weitere Methoden zur Verfügung. Folgende Funktionen gibt es:

- `.delete(url, **kwargs)`: Mit `.delete()` entfernen Sie eine bestimmte Quelle
- `.get(url, parameter=None, **kwargs)`: Mit `.get()` fragen Sie Informationen von einem Server ab
- `.head(url, **kwargs)`: Mit `.head()` fragen Sie ebenfalls eine Antwort von einem Server an, beschränken sich dabei aber auf den Header
- `.patch(url, data=None, **kwargs)`: Mit `.patch()` können Sie die Leistungsfähigkeit erhöhen. Es werden damit nur Änderungen an die Quelle gesendet
- `.post(url, data=None, json=None, **kwargs)`: Mit `.post()` übermitteln Sie vor allem Formularangaben an einen Server
- `.put(url, data=None, **kwargs)`: Mit `.put()` modifizieren Sie eine bestehende Quelle und erzeugen neue Daten auf dem Server
- `.request(method, url, **kwargs)`: Mit `.request()` senden Sie eine Anfrage mit einer bestimmten Methode an die URL

## Beispiel für die Methode `.get()`

Der Aufbau von `.get()` ist sehr übersichtlich, was Python `requests` zu einer praktischen Bibliothek macht. Sie benötigen nicht mehr als die Methode und die URL, die Sie ansprechen wollen. Diese wird in Anführungszeichen geschrieben. So sieht ein derartiger Code beispielhaft aus:

```python
import requests
requests.get("https://beispiel.com")
```

Nun erhalten Sie eine Antwort von Ihrem Zielserver. Zur Veranschaulichung können Sie sich diese auch in einer Variablen anzeigen lassen. Für unser Beispiel sähe das so aus:

```python
import requests
response = requests.get("https://beispiel.com")
```

## Status-Codes abfragen

Die einfachste Antwort, die Sie auf eine Anfrage erhalten, ist ein [HTTP-Status-Code](https://www.ionos.de/digitalguide/hosting/hosting-technik/die-wichtigsten-http-status-codes-im-ueberblick/). Dieser zeigt Ihnen, ob Ihre Anfrage erfolgreich war oder nicht. Der Status-Code ist dreistellig. Es gibt zahlreiche Varianten, die Sie über den Verlauf Ihrer Anfrage unterrichten. Die wichtigsten Kategorien sind diese:

- **1XX**: Enthält weiterführende Informationen
- **2XX**: Bescheinigt eine erfolgreiche Anfrage
- **3XX**: Informiert Sie über eine Umleitung Ihrer Anfrage
- **4XX**: Meldet einen Fehler auf der Client-Seite
- **5XX**: Meldet einen Fehler auf der Server-Seite

Zu den bekanntesten Status-Codes gehören „200 – OK“ (für eine erfolgreiche Anfrage) und „[404 – Not Found](https://www.ionos.de/digitalguide/websites/webseiten-erstellen/was-bedeutet-der-error-404-not-found/)“ (falls die angeforderten Daten auf dem Server nicht gefunden wurden).

Nach Ihrer Anfrage über Python `requests` können Sie mit `.status_code` den Status abfragen. Dafür nutzen Sie diesen Code:

```python
response.status_code
```

War die Anfrage erfolgreich erhalten Sie diese Ausgabe:

```python
200
```

Zur besseren Darstellung eignet sich auch der folgende Code:

```python
if response.status_code == 200:
	print("Die Anfrage war erfolgreich.")
elif response.status_code == 404:
	print("Die Anfrage war nicht erfolgreich.")
```

## Header einsehen mit Python `requests`

Im Header einer HTTP-Antwort sind zahlreiche nützliche Informationen enthalten. Unter anderem finden Sie hier den **mitgesendeten Datentyp, ein Zeitlimit für die Zwischenspeicherung** und weitere Angaben. Mit der Bibliothek Python `requests` können Sie sich den Header auch einfach anzeigen lassen. Dafür führen Sie zunächst die Funktion `.get()` und danach `.headers` aus:

```python
import requests
response = requests.get("https://beispiel.com")
response.headers
```

In der Ausgabe erhalten Sie dadurch ein Objekt, in dem die Werte aus dem Header enthalten sind. Diese können Sie auch einzeln abfragen, indem Sie den Befehl spezifizieren. Möchten Sie zum Beispiel mehr über den Datentyp erfahren, ist dies die richtige Eingabe:

```python
response.headers["content-type"]
```

## Auf den Payload zugreifen

Das Datenpaket, das **zwischen Server und Client verschickt** wird, ist auch als „Payload“ bekannt. Es befindet sich im Body oder Körper der Antwort. Mit `response` können Sie auf die dort enthaltenen Informationen zugreifen. Für eine Darstellung in Bytes ist diese Anweisung die passende:

```python
import requests
response = requests.get("https://beispiel.com")
response.content
type(response.content)
```

Möchten Sie die so gesammelten Informationen in einen String umwandeln, nutzen Sie diesen Code:

```python
response.text
type(response.text)
```

Python `requests` wird die Verschlüsselung dem Header entnehmen. Alternativ weisen Sie das System an, eine andere Methode zu nutzen. Dafür ist dieser Code ein Beispiel:

```python
response.encoding = "utf-8"
response.text
```

## Fortschritt überprüfen

Wenn Sie eine Anfrage senden, wird diese von Python `requests` vorbereitet, um unliebsame Fehler zu vermeiden. Dabei wird unter anderem der **Header überprüft**. Den Fortschritt dieser Methode können Sie mithilfe der Funktion `.request` überprüfen. Dafür verwenden Sie diesen Code:

```python
import requests
response = requests.post("https://beispiel.com", json={"key": "value"})
print(response.request.headers["content-type"])
print(response.request.url)
print(response.request.body)
```

So erhalten Sie Informationen zum Payload, dem Header, der URL und vielen weiteren Punkten.

## Echtheitsprüfung via Python`requests`-Module

Der Parameter `auth` wird in Python `requests` genutzt, um eine Authentifizierung an den Server zu senden. Dieser kann eine Echtheitsprüfung durchführen und so kontrollieren, mit wem er eigentlich interagiert. Um die Überprüfung zu nutzen, wenden Sie einen Code wie diesen an:

```python
import requests
from requests.auth import HTTPBasicAuth
response = requests.get("https://ihre_seite.com/basic-auth/user/passwd", 
	auth=HTTPBasicAuth("user", "passwd"))
print(response.status_code)
print(response.request.headers["Authorization"])
```

## SSL-Zertifikat nutzen

Grundsätzlich ist die Nutzung eines [SSL-Zertifikats](https://www.ionos.de/digitalguide/websites/webseiten-erstellen/ssl-zertifikat/) sinnvoll, um Datenverlust und ungewollte Eingriffe zu verhindern. Python `requests` bietet diese Option standardmäßig an. Möchten Sie die gegenseitige Verifikation allerdings **für eine Anfrage unterbinden**, können Sie SSL mit diesem Code ausschalten:

```python
import requests
requests.get("https://beispiel.com", verify=False)
```

Sie erhalten dann allerdings eine ausdrückliche Warnmeldung.

## Timeout mit Python `requests` initiieren

Mit Python `requests` können Sie unter anderem auch die **maximale Zeit für eine Antwort beschränken**. Standardmäßig wird der Client ohne Einschränkung auf eine Reaktion warten. Bleibt diese aus, können sich Anfragen stauen und die Leistung leidet darunter. Mit dem Parameter `timeout` verhindern Sie dieses Problem. Im folgenden Code weisen wir Python `requests` an, die Anfrage nach zwei Sekunden abzubrechen:

```python
requests.get("https://beispiel.com", timeout=2)
```

Tipp Deployen Sie Ihre Website oder App direkt via GitHub: Mit [Deploy Now](https://www.ionos.de/hosting/deploy-now "Deploy Now von IONOS") von IONOS erhalten Sie die optimale Lösung für Single-Page-Applikationen und statische Websites gleichermaßen. Wählen Sie den passenden Tarif für Ihre Zwecke und profitieren Sie von einem schnelleren Setup, optimierten Workflows und einem sicheren Design!


This is a markdown version of: [https://www.ionos.de/digitalguide/websites/web-entwicklung/python-requests-module/](https://www.ionos.de/digitalguide/websites/web-entwicklung/python-requests-module/) for AI/LLM consumption.