Multimedia-WhatsApp-Nachrichten über API automatisieren

Warum sich mit einfachem Text zufriedengeben, wenn du automatisch Videos, Bilder, GIFs und Dateien senden kannst? Mit nur ein wenig Code kannst du deine WhatsApp-Kommunikation aufwerten und jede Nachricht persönlicher, ansprechender und wirkungsvoller gestalten.

Dieser Leitfaden ist für alle gedacht, ob du Entwickler bist oder gerade anfängst, dich mit APIs zu beschäftigen. Wir zeigen dir, wie du reichhaltige Medieninhalte über WhatsApp mit Wassenger direkt von deinem Computer aus senden kannst.

Es ist einfacher, als du denkst — und das Ergebnis? Viel spaßiger und deutlich effektiver. Los geht’s, geben wir deinen Nachrichten das Upgrade, das sie verdienen.

🤩 🤖 Wassenger ist eine vollständige Kommunikationsplattform und API-Lösung für WhatsApp. Entdecke mehr als 100+ API-Anwendungsfälle und automatisiere alles auf WhatsApp indem du dich anmeldest für eine kostenlose Testversion und in wenigen Minuten startest!

In diesem Tutorial lernst du, wie du Multimedia-Nachrichten an Telefonnummern und Gruppenlisten per API sendest.

Eine Mediendatei kann eine der folgenden Arten sein: Bilder (JPEG, PNG, WEBP), Videos (MP4, 3GPP), Audios (MP3, OGG, MP4, ACC), GIFs (MP4) und Dokumente (PDF, PPT, PPTX, DOCX, DOC, ZIP, RAR, andere Binärtypen).

Wenn du Nachrichten aus Code heraus senden möchtest, kannst du jede Programmiersprache verwenden, die HTTPS-Anfragen an die API ausführen kann. Weiter unten findest du den Live-API-Tester mit sofort einsatzbereiten Codebeispielen in verschiedenen Programmiersprachen.

Anforderungen

Eine bereits mit der Plattform verknüpfte und online befindliche WhatsApp-Nummer.
Empfängertelefonnummer mit internationaler Vorwahl im E164-Format. Beispiel: +12345678900. Überprüfe das Telefonnummernformat hier.

API-Endpunkte

In diesem Tutorial verwenden wir die folgenden API-Endpunkte:

Breaking news! Du kannst jetzt Mediennachrichten in einer einzigen API-Anfrage senden, indem du die entfernte URL angibst, unter der die Datei gespeichert ist. Klicke hier, um es zu testen

Datei hochladen

Um eine Datei als Multimedia-Nachricht zu versenden — in diesem Fall eine Bilddatei — musst du die Datei zuerst auf die Plattform hochladen.

Du kannst die Datei mit den folgenden Methoden über die API hochladen:

Remote-URL mit JSON, das ein url-Feld mit der öffentlich zugänglichen URL enthält, unter der die Datei heruntergeladen werden kann (empfohlen).
Formulardaten (multipart/form-data) mit dem file-Feld und dem Dateiinhalt.
Roh-Binärdaten, indem du den Dateiinhalt als Datenstrom mit dem passenden MIME-Typ im Content-Type-Header hochlädst, z. B.: image/jpeg, application/pdf.

In diesem Tutorial behandeln wir die ersten beiden Methoden zum Hochladen von Dateien.

Das Hochladen der Datei ermöglicht dem System, die Datei nur einmal zu validieren und zu speichern, wodurch die Upload- und Verarbeitungsaufwände bei jeder Zustellung einer Mediennachricht entfallen. Das verbessert die Zustellgeschwindigkeit und vereinfacht die API-Integration.

Beachte, dass die hochgeladene Datei standardmäßig 90 Tage auf der Plattform gespeichert wird, weshalb du in vielen Fällen die Datei nur einmal hochladen musst. Optional kannst du auch konfigurieren, wie lange die Datei auf der Plattform gespeichert werden soll indem du eine benutzerdefinierte Ablaufzeit definierst. Für mehr Details siehe die API-Dokumentation. Standardmäßig hat dein Konto 10 GB Speicherplatz für Dateien in der Cloud.

Datei mit einer Remote-URL hochladen

Du kannst jede Datei auf die Plattform hochladen, indem du einfach die öffentliche URL angibst, von der die Datei heruntergeladen werden kann.

Falls die URL nicht öffentlich zugänglich ist, einen ungültigen HTTP-Status (>=400) zurückliefert oder keinen Binärinhalt (z. B. HTML oder Text) liefert, gibt die API einen Fehler zurück.

Ziel-API-URL (POST)

https://api.wassenger.com/v1/files

Erforderliche HTTPS-Header

Content-Type: application/json
Token: $API-TOKEN

Request-Body im JSON-Format

{
  "url": "https://picsum.photos/seed/picsum/600/400"
}

Alternativ kannst du beim Hochladen der Datei auch optionale Felder angeben, wie z. B. eine benutzerdefinierte Ablaufzeit, eine Referenzkennung oder einen benutzerdefinierten Dateinamen.

{
  "url": "https://picsum.photos/seed/picsum/600/400",
  "expiration": "1d",
  "filename": "custom-filename.jpg",
  "reference": "Optional reference ID"
}

Datei-ID aus der API-Antwort erhalten

Wenn die Datei korrekt auf die Plattform hochgeladen wurde, gibt die API eine gültige JSON-Antwort wie diese zurück:

[
  {
    "id": "[Redacted ID]",
    "format": "native",
    "filename": "sample.jpg",
    "size": 53697,
    "mime": "image/jpeg",
    "ext": "jpeg",
    "kind": "image",
    "sha2": "[Redacted Hash]",
    "tags": [],
    "status": "active",
    "mode": "default",
    "createdAt": "2021-05-08T22:49:50.954Z",
    "expiresAt": "2021-09-06T22:49:50.949Z"
  }
]

Wichtig: Aus dem Antwort-JSON solltest du das Feld id entnehmen, z. B. 06248ed01a7a65946c0701, das die eindeutige Datei-ID darstellt, die wir später verwenden, um die Datei in einer separaten API-Anfrage als Mediennachricht zu senden.

Datei per Multipart-Formulardaten hochladen

Du kannst jede Datei auf die Plattform hochladen, indem du den traditionellen Multipart-Form-Data-Mechanismus verwendest, der von Webbrowsern weit verbreitet zum Hochladen verschiedener Inhalte, einschließlich Dateien, auf entfernte Server genutzt wird.

Hier erfährst du mehr darüber, wie Multipart-Form-Uploads funktionieren.

Ziel-API-URL (POST)

https://api.wassenger.com/v1/files

Erforderliche HTTPS-Header

Content-Type: multipart/form-data
Token: $API-TOKEN

Request-Body

Im Unterschied zum JSON-basierten Upload müssen wir hier auf einen komplexeren Mechanismus zurückgreifen, der vom verwendeten HTTP-Client unterstützt wird und uns beim Zusammensetzen der Formularfelder gemäß der Multipart-Spezifikation hilft.

Je nach Programmiersprache oder HTTP-Client-Software, die du verwendest, kann der Prozess variieren. Der Einfachheit halber heben wir die beliebtesten Tools hervor, wie z. B. Postman, sowie gängige Programmiersprachen.

Die Kernanforderung ist, das Feld file im Formular anzugeben, andernfalls gibt die API einen Fehler zurück, da dieses Feld verpflichtend ist.

🤩 🤖 Wassenger ist eine vollständige Kommunikationsplattform und API-Lösung für WhatsApp. Entdecke mehr als 100+ API-Anwendungsfälle und automatisiere alles auf WhatsApp indem du dich für eine kostenlose Testversion anmeldest und in wenigen Minuten startest**!**

Datei über den Webbrowser hochladen

Du kannst Dateien manuell ganz einfach über die Web-Konsole in die Plattform hochladen, ohne Software zu installieren:

Upload new file

Für automatisierte Uploads siehe bitte die alternativen Optionen weiter unten.

Datei mit cURL hochladen

cURL ist ein beliebter und nützlicher Kommandozeilen-HTTP-Client.

Du kannst Dateien einfach über die Kommandozeile hochladen, indem du den folgenden Befehl verwendest; path/to/image.jpg sollte dabei den Pfad zur Datei auf deiner Festplatte darstellen:

curl \
-F file=@path/to/image.jpg \
-H 'Token: $API-TOKEN' \
https://api.wassenger.com/v1/files

Datei mit Postman hochladen

Postman ist ein vielseitiges und praktisches Tool für HTTP-Tests und Debugging.

Mit folgendem einfachen Tutorial kannst du Dateien mit Postman hochladen, indem du die Ziel-URL durch die API-URL ersetzt.

Erkunde das Postman-Tutorial hier

Datei mit Code hochladen

Erkunde, wie du den Code in deinem Browser verwenden kannst, ohne Software zu installieren.

Außerdem findest du verschiedene Sprachen, die du auf Replit.com testen kannst:

Python

# Requires to install requests package:
# Run: pip install requests
import requests
# Customize the local path of the file to upload
filepath = '/path/to/image.jpg'
# API key required in order to authenticate the upload
apikey = '$API_KEY'
# Read file to upload
files = {'file': open(filepath, 'rb')}
# Upload file
response = requests.post('https://api.wassenger.com/v1/files', files=files)
if response.status_code >= 400:
print('Request failed with invalid status:', response.status_code)
else:
json = response.json()
file_id = json[0]['id']
print('File uploaded successfully with ID:', file_id)

PHP (Curl)

// Customize the local path of the file to upload
$filepath = '/path/to/image.jpg';
// API key required in order to authenticate the upload
$apikey = '$API_KEY';
// Upload file
$upload = curl_init();
curl_setopt_array($upload, array(
CURLOPT_URL => 'https://api.wassenger.com/v1/files', 
CURLOPT_HTTPHEADER => array(
"Token: $apikey"
), 
CURLOPT_POSTFIELDS => array(
'file' => new CURLFile($filepath)
), 
CURLOPT_POST => TRUE, 
CURLOPT_SSL_VERIFYPEER => FALSE, 
CURLOPT_SSL_VERIFYHOST => FALSE
);
$response = curl_exec($upload);
if(curl_errno($ch) {
echo("Request failed");
} else if(curl_getinfo($ch, CURLINFO_HTTP_CODE) >= 400) {
echo("Invalid request or unsupported file to upload");
} else {
$json = json_decode($response, true);
$file_id = $json[0]['id'];
echo("File uploaded successfully with ID: $file_id");
}

// Requires to install pecl_http package
// Run: pecl install pecl_http
// More information: https://pecl.php.net/package/pecl_http/3.2.0
$client = new http\Client;
$request = new http\Client\Request;
// Customize the local path of the file to upload
$filepath = '/path/to/image.jpg';
// API key required in order to authenticate the upload
$apikey = '$API_KEY';
// Prepare request
$body = new http\Message\Body;
$body->addForm(null, [
[
'name' => 'file', 
'type' => null, 
'file' => $filename, 
'data' => null
]
]);
$request->setRequestUrl('https://api.wassenger.com/v1/files');
$request->setRequestMethod('POST');
$request->setBody($body);
$request->setQuery(new http\QueryString([
'reference' => 'optional-reference-id'
]));
$request->setHeaders([
'Token' => $apikey
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
if($response->getResponseCode() >= 400) {
echo("Invalid request or unsupported file to upload");
} else {
$body = json_decode($response->getBody()->toString());
$file_id = $json[0]['id'];
echo("File uploaded successfully with ID: $file_id");
}

package main
import(
"net/http"
"os"
"bytes"
"path"
"path/filepath"
"mime/multipart"
"io"
"encoding/json"
)
// API key required in order to authenticate the upload
const apiKey = "$API_KEY"
func main() {
# Customize the local path of the file to upload
fileName:= "path/to/image.jpg"
fileDir, _:= os.Getwd()
filePath:= path.Join(fileDir, fileName)
file, _:= os.Open(filePath)
defer file.Close()
body:= &bytes.Buffer{}
writer:= multipart.NewWriter(body)
part, _:= writer.CreateFormFile("file", filepath.Base(file.Name()))
io.Copy(part, file)
writer.Close()
r, _:= http.NewRequest("POST", "https://api.wassenger.com/v1/files", body)
r.Header.Add("Token", apiKey)
r.Header.Add("Content-Type", writer.FormDataContentType())
client:= &http.Client{Timeout: 90 * time.Second}
response, err:= client.Do(r)
if err != nil {
fmt.Printf("Request failed with an error: %s", err.Error())
return
}
if(response.StatusCode >= 400) {
fmt.Printf("Request failed with response status: %d", response.StatusCode)
return
}
body:= []struct{
Id string `json:"id"`
}{}
defer response.Body.Close()
err:= json.NewDecoder(response.Body).Decode(&body)
if err != nil {
fmt.Printf("Failed to decode JSON: %s", err.Error())
return
}
fileId:= body[0].Id
fmt.Printf("File uploaded successfully with ID:", fileId)
}

RestClient restClient = new RestClient("https://api.wassenger.com");
RestRequest restRequest = new RestRequest("/v1/files");
restRequest.Method = Method.POST;
restRequest.AddHeader("Token", "$API_KEY");
restRequest.AddHeader("Content-Type", "multipart/form-data");
restRequest.AddFile("file", "/path/to/image.jpg");
var response = restClient.Execute(restRequest);
var json = JsonConvert.DeserializeObject(response.Content);
var fileId =(string)json[0]["id"];
Console.WriteLine("File uploaded successfully with ID: {0}", fileId);

Ruby

require 'net/http/post/multipart'
url = URI.parse('https://api.wassenger.com/v1/files')
File.open("/path/to/image.jpg") do |image|
req = Net::HTTP::Post::Multipart.new url.path, "file" => UploadIO.new(image, "image/jpeg", "image.jpg")
req['Token'] = "API_KEY"
res = Net::HTTP.start(url.host, url.port) do |http|
http.request(req)
end
end

Java

List<File> = Unirest.post("https://api.wassenger.com/v1/files")
.header("Token", "API_KEY")
.field("file", new File("/path/to/image.jpg"))
.getBody()

🤩 🤖 Wassenger ist eine vollständige Kommunikationsplattform und API-Lösung für WhatsApp. Entdecke mehr als 100+ API-Anwendungsfälle und automatisiere alles auf WhatsApp indem du dich anmeldest für eine kostenlose Testversion und in wenigen Minuten startest!

Live-Test des Datei-Uploads mit der API

Erkunde unseren API-Live-Tester

Mediennachrichten an eine Telefonnummer senden

Eine neue Mediennachricht per API zu senden ist einfach — du musst lediglich die Zieltelefonnummer im E164-Format und die hochgeladene Datei-ID (24-stellige hexadezimale ID) kennen, die du in der Liste der hochgeladenen Dateien hier oder über die API-Liste der hochgeladenen Dateien erhalten kannst.

Du kannst Nachrichten an jede Telefonnummer weltweit senden, die ein WhatsApp-Konto hat — es ist nicht nötig, die Telefonnummer als Kontakt in deinem Telefonbuch zu speichern.

Anfrage vorbereiten

Ziel-API-URL (POST)

https://api.wassenger.com/v1/messages

Erforderliche HTTPS-Header

Content-Type: application/json
Token: $API_KEY

Request-Body im JSON-Format

{
  "phone": "+12345678900",
  "message": "This is a media message example 😀",
  "media": {
    "file": "UPLOADED FILE ID GOES HERE"
  }
}

Du kannst jetzt die Mediennachricht über die API senden.

Mediennachrichten an eine Gruppe senden

Sehr ähnlich zum vorherigen Szenario kannst du auch Mediennachrichten an Gruppen-Chats senden.

Um Nachrichten an eine Gruppe zu senden, musst du Teilnehmer der Gruppe sein und über Sende-Berechtigungen verfügen. Wenn du Administrator der Gruppe bist, hast du vollständige Berechtigungen zum Senden von Nachrichten.

Anfrage vorbereiten

Ziel-API-URL (POST)

https://api.wassenger.com/v1/messages

Erforderliche HTTPS-Header

Content-Type: application/json
Token: $API_KEY

Request-Body im JSON-Format

Senden einer Nachricht an einen Gruppenchat:

{
  "group": "120363163556487865@g.us",
  "message": "This is a media message example sent a group 😀",
  "media": {
    "file": "UPLOADED FILE ID GOES HERE"
  }
}

Live-Test: Mediennachrichten mit der API senden

Du kannst die API jetzt direkt im Browser testen, debuggen und live ausprobieren. Erkunde und teste weitere API-Beispiele und erhalte mit einem Klick einsatzbereite Code-Snippets in über 15 verschiedenen Programmiersprachen 😎

Jetzt ausprobieren

🤩 🤖 Wassenger ist eine vollständige Kommunikationsplattform und API-Lösung für WhatsApp. Entdecke mehr als 100+ API-Anwendungsfälle und automatisiere alles auf WhatsApp indem du dich anmeldest für eine kostenlose Testversion und in wenigen Minuten startest!

Häufig gestellte Fragen

Welche Arten von Mediendateien können gesendet werden?

Du kannst Bilder (JPEG, PNG, WEBP), Videos (MP4, 3GPP), Audios (MP3, OGG, MP4, ACC), GIFs (MP4) und Dokumente (PDF, PPT, PPTX, DOCX, DOC, ZIP, RAR, andere Binärtypen) senden.

Siehe die API-Dokumentation für weitere Details.

Wie sende ich Nachrichten an mehrere Telefonnummern?

Du musst einfach mehrere API-Anfragen senden, jeweils eine pro Zieltelefonnummer.

Wenn du z. B. eine Nachricht an 10 Telefonnummern senden möchtest, musst du 10 unabhängige HTTPS-Anfragen an die API schicken.

Es gibt keine Option, mehrere Nachrichten in einer einzigen API-Anfrage zu senden.

Wie überprüfe ich, ob eine Telefonnummer WhatsApp-Nachrichten empfangen kann?

Du kannst prüfen, ob eine Telefonnummer mit einem WhatsApp-Konto verknüpft ist und Nachrichten empfangen kann.

Die API stellt einen Endpunkt bereit, der validieren kann, ob eine Telefonnummer bei WhatsApp existiert oder nicht.

Voraussetzung ist, dass mindestens eine WhatsApp-Nummer in deinem aktuellen Konto mit der Plattform verbunden ist.

Weitere Details findest du in der API-Endpunkt-Dokumentation hier.

Bevor du prüfst, ob eine Telefonnummer bei WhatsApp existiert, kannst du auch das Format einer Liste von Telefonnummern mithilfe des Numbers Validator API-Endpunkts validieren und normalisieren. Dieser Endpunkt überprüft nur das korrekte E164-Format, er prüft jedoch nicht, ob die Telefonnummer tatsächlich bei WhatsApp existiert.

Hinweis: Die Anzahl der WhatsApp-Validierungen ist pro Monat anhand deines Abonnementplans begrenzt. Bitte sieh dir die Preistabelle für weitere Details zu den Limits an.

Suchst du nach weiteren Antworten? Sieh dir die erweiterten FAQs an.

Weitere nützliche Ressourcen

API-Dokumentation

Für mehr Details zu den API-Endpunkten, siehe die Dokumentation, in der du alle Informationen zu akzeptierten Request-Parametern, möglichen Erfolg- oder Fehlerantworten sowie einsatzbereite Codebeispiele in mehreren Programmiersprachen findest:

https://app.wassenger.com/docs/#tag/Files