Multimedia-WhatsApp-Nachrichten über API senden

Willkommen in der energiegeladenen Welt des API-gesteuerten Multimedia-Messaging! Hier hast du die Chance, deine WhatsApp-Unterhaltungen zu revolutionieren, indem du nicht nur Text, sondern eine ganze Reihe von Medientypen sendest. Stell dir vor, du peppst deine Nachrichten mit coolen GIFs, wichtigen Dokumenten oder sogar fesselnden Videos direkt von deinem Computer aus auf!

Dieses Tutorial ist nicht nur für Technik-Profis. Egal, ob du gerade mit dem Programmieren anfängst oder schon länger herumprobierst — du wirst sehen, wie ein paar Zeilen Code deine Nachrichten zum Leben erwecken können. Wir sprechen davon, deine Konversationen reichhaltiger und farbenfroher zu machen und jede gesendete Nachricht in ein Erlebnis zu verwandeln.

Bereit, deinen Chats etwas Würze zu geben und dein Publikum auf ganz neue Weise zu erreichen? Dann tauchen wir ein in dieses Multimedia-Abenteuer und sehen, wie einfach es ist, deine Nachrichten zum Strahlen zu bringen!

🤩 🤖 Wassenger ist eine komplette 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 Testphase anmeldest und in wenigen Minuten startest**!**

In diesem Tutorial lernst du, wie man Multimedia-Nachrichten an Telefonnummern und Gruppenlisten mithilfe der API sendet.

Eine Mediendatei kann eine der folgenden 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 musst, kannst du jede Programmiersprache verwenden, die HTTPS-Anfragen an die API ausführen kann. Unten findest du den Live API-Tester mit einsatzbereiten Codebeispielen in verschiedenen Programmiersprachen.

Voraussetzungen

Eine WhatsApp-Nummer, die bereits mit der Plattform verbunden und online ist.
Empfänger-Telefonnummer im internationalen Präfix im E164-Format. Beispiel: +12345678900. Validieren Sie das Telefonnummernformat hier.

API-Endpunkte

In diesem Tutorial verwenden wir folgenden API-Endpunkt:

Neuigkeiten! Du kannst jetzt Mediennachrichten in einer einzigen API-Anfrage senden, indem du die Remote-URL angibst, unter der die Datei gespeichert ist. Hier klicken, um es zu testen

Datei hochladen

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

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

Remote-URL mittels JSON mit einem url-Feld, das die öffentlich zugängliche URL zum Herunterladen der Datei enthält (empfohlen).
Formulardaten (multipart/form-data) mit dem file-Feld und dem Dateiinhalts.
Roh-Binärdaten, indem du den Dateiinhalt als Datenstrom mit dem entsprechenden MIME-Typ im Content-Type-Header hochlädst, z. B.: image/jpeg, application/pdf.

In diesem Tutorial behandeln wir die ersten beiden Methoden des Datei-Uploads.

Das Hochladen der Datei ermöglicht es dem System, die Datei nur einmal zu validieren und zu speichern, wodurch die Upload- und Verarbeitungskosten bei jeder Zustellung einer Mediensendung vermieden werden. Das verbessert die Zustellgeschwindigkeit der Nachricht und vereinfacht die API-Integration.

Beachte, dass die hochgeladene Datei standardmäßig 90 Tage auf der Plattform gespeichert wird. In vielen Fällen musst du die Datei also nur einmal hochladen. 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 Dateispeicherplatz in der Cloud.

Datei per Remote-URL hochladen

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

Wenn die URL nicht öffentlich zugänglich ist, einen ungültigen HTTP-Status (>=400) zurückgibt oder keinen Binärinhalt wie 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"
}

Die Datei-ID aus der API-Antwort erhalten

Wenn die Datei korrekt auf die Plattform hochgeladen wurde, gibt die API eine gültige Antwort im JSON-Format zurück, die so aussehen kann:

[
  {
    "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 JSON-Response solltest du das Feld id erhalten, z. B. 06248ed01a7a65946c0701, das die eindeutige Datei-ID repräsentiert, die wir später verwenden, um die Datei als Mediensendung in einer separaten API-Anfrage zu versenden.

Datei mit multipart/form-data hochladen

Du kannst jede Datei auf die Plattform hochladen, indem du den traditionellen Multipart-Formular-Mechanismus verwendest, der häufig von Webbrowsern genutzt wird, um verschiedene Inhaltstypen — einschließlich Dateien — an einen entfernten Server zu senden.

Hier kannst du mehr darüber erfahren, 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 abhängt und uns hilft, die Formularfelder gemäß der Multipart-Spezifikation zusammenzustellen.

Je nach Programmiersprache oder HTTP-Client-Software kann der Prozess variieren. Der Einfachheit halber heben wir die beliebtesten Werkzeuge hervor, wie Postman, und gängige Programmiersprachen.

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

🤩 🤖 Wassenger ist eine komplette 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 Testphase anmeldest und in wenigen Minuten startest**!**

Datei in deinem Webbrowser hochladen

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

Neue Datei hochladen

Für automatisierte Datei-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 von der Kommandozeile hochladen, wobei path/to/image.jpg den Pfad zur Datei auf deiner Festplatte darstellen sollte:

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.

Folge diesem einfachen Tutorial, um Dateien mit Postman hochzuladen, und ersetze die Ziel-URL durch die API.

Das Postman-Tutorial hier entdecken

Datei mit Code hochladen

Erforsche, wie du den Code in deinem Browser ohne Softwareinstallation verwenden kannst.

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 komplette 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 Testphase anmeldest und in wenigen Minuten startest**!**

Live-Test: Datei-Upload über die API

Entdecke unseren API-Live-Tester

Mediennachrichten an eine Telefonnummer senden

Das Senden einer neuen Mediennachricht über die API ist einfach: Du musst lediglich die Zieltelefonnummer im E164-Format und die hochgeladene Datei-ID (24 hexadezimale Zeichen) kennen, die du hier in der Liste der hochgeladenen Dateien oder über die API-Auflistung hochgeladener Dateien erhalten kannst.

Du kannst Nachrichten an jede Telefonnummer weltweit senden, die ein WhatsApp-Konto hat. Es ist nicht erforderlich, 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 Gruppenchats senden.

Um Nachrichten an eine Gruppe zu senden, musst du Teilnehmer der Gruppe mit Sende-Rechten sein. Wenn du Administrator der Gruppe bist, hast du volle Rechte 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 über die API senden

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

Jetzt ausprobieren

🤩 🤖 Wassenger ist eine komplette 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 Testphase anmeldest und in wenigen Minuten startest**!**

FAQs

Welche Medientypen 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 mehr Details.

Wie sende ich Nachrichten an mehrere Telefonnummern?

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

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

Es gibt keine Möglichkeit, mehrere Nachrichten in einer einzigen API-Anfrage zu senden.

Wie kann man validieren, ob eine Telefonnummer WhatsApp-Nachrichten empfangen kann?

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

Die API stellt einen Endpunkt zur Verfügung, der validieren kann, ob eine gegebene Telefonnummer bei WhatsApp existiert oder nicht.

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

Für weitere Details schaue dir bitte die API-Endpunkt-Dokumentation hier an.

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

Hinweis: Die Anzahl der WhatsApp-Prüfungen ist pro Monat basierend auf deinem Abonnementplan begrenzt. Bitte sieh dir die Preistabelle für weitere Details zu den Limits an.

Suchst du nach mehr 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 über akzeptierte Request-Parameter, mögliche Erfolgs- oder Fehler-Antworten und einsatzbereite Codebeispiele in mehreren Programmiersprachen findest:

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