Dify API Anleitung 2026: KI per REST in deine App integrieren
Die Dify REST API ermöglicht es dir, jede Dify-App aus eigenem Code heraus aufzurufen — einen Chatbot in deine Website einbetten, Dokumentenverarbeitung automatisieren oder KI-Funktionen in beliebige SaaS-Produkte integrieren. Diese Anleitung deckt alles ab: vom API-Schlüssel bis zu Streaming-Antworten und Self-Hosted-Setups.
Was ist die Dify API?
Die Dify API ist eine REST API, mit der du jede in Dify erstellte App programmatisch aufrufen kannst — aus jeder Programmiersprache oder Plattform. Sobald du eine Dify-App veröffentlichst (Chatbot, Agent, Workflow oder Completion-App), erhält sie einen eigenen API-Endpunkt, den du mit einem Secret Key aufrufen kannst.
Die Basis-URL für Dify Cloud ist https://api.dify.ai/v1. Beim Self-Hosting ersetzt du diese durch deine eigene Domain: https://dein-server.com/v1.
Typische Anwendungsfälle
Website-Chatbot
KI-Chat in jede Website einbetten, ohne das Dify-Widget zu nutzen.
Dokumentenautomatisierung
PDFs oder Texte an einen Dify-Workflow senden und strukturierte Ausgabe erhalten.
SaaS KI-Funktionen
KI-Schreiben, Zusammenfassung oder Q&A in bestehende Produkte einbauen.
Backend-Pipelines
Dify-Agents aus Cron-Jobs, Webhooks oder Queue-Prozessoren auslösen.
Mobile Apps
Dify aus iOS- oder Android-Apps über Standard-HTTP aufrufen.
No-Code-Tools
Dify über HTTP-Request-Nodes mit n8n, Make oder Zapier verbinden.
API-Schlüssel erstellen
Jede Dify-App hat ihren eigenen API-Schlüssel. Du musst für jede App, auf die du per API zugreifen möchtest, einen erstellen. So geht's:
Öffne deine Dify-App im Studio
Gehe zu cloud.dify.ai (oder deiner Self-Hosted URL) und öffne die App, die du per API aufrufen möchtest.
Klicke oben rechts auf "API Access"
Dies öffnet das API-Referenzpanel für genau diese App.
Klicke auf "API Key erstellen"
Gib ihm einen Namen (z.B. "produktion" oder "test"), um ihn später zu identifizieren.
Kopiere den Secret Key sofort
Der Key wird nur einmal angezeigt. Speichere ihn als Umgebungsvariable — niemals direkt im Quellcode.
Verwende ihn im Authorization-Header
Alle API-Anfragen benötigen diesen Header: Authorization: Bearer DEIN_API_KEY
Übersicht der API-Endpunkte
Die Dify API bietet Endpunkte zum Senden von Nachrichten, Verwalten von Konversationen, Hochladen von Dateien und mehr. Alle Endpunkte sind relativ zur Basis-URL https://api.dify.ai/v1.
| Methode | Endpunkt | Beschreibung |
|---|---|---|
| POST | /chat-messages | Chat-Nachricht senden und Antwort empfangen. Unterstützt blocking und streaming. |
| POST | /completion-messages | Prompt an eine Completion-App senden. Gibt einen generierten Text zurück. |
| POST | /files/upload | Datei hochladen (PDF, Bild usw.) für RAG oder Vision-Apps. |
| GET | /conversations | Alle Konversationen eines Nutzers auflisten. Nutze den user-Parameter zur Filterung. |
| GET | /messages | Nachrichtenverlauf einer bestimmten Konversation abrufen. |
| DELETE | /conversations/:id | Eine Konversation und alle ihre Nachrichten dauerhaft löschen. |
| POST | /messages/:id/feedbacks | Bewertung (Daumen hoch/runter) für eine bestimmte Nachricht abgeben. |
| GET | /parameters | Eingabeparameter, Einführungstext und Vorschlagsfragen der App abrufen. |
Dein erster API-Aufruf
Lass uns einen echten API-Aufruf durchführen. Ersetze DEIN_API_KEY durch deinen tatsächlichen Schlüssel. Das user-Feld ist ein eindeutiger Bezeichner für den Endnutzer — verwende einen beliebigen String, der diesen in deinem System identifiziert.
curl-Beispiel
curl -X POST 'https://api.dify.ai/v1/chat-messages' \
-H 'Authorization: Bearer DEIN_API_KEY' \
-H 'Content-Type: application/json' \
-d '{
"inputs": {},
"query": "Hallo! Wobei kannst du mir helfen?",
"response_mode": "blocking",
"conversation_id": "",
"user": "nutzer-123"
}' Beispiel-Antwort
{
"event": "message",
"task_id": "abc123",
"id": "msg_456",
"message_id": "msg_456",
"conversation_id": "conv_789",
"mode": "chat",
"answer": "Hallo! Ich kann dir bei Fragen, Texten, Analysen und vielem mehr helfen. Was möchtest du erkunden?",
"metadata": { "usage": { "prompt_tokens": 12, "completion_tokens": 22 } },
"created_at": 1711234567
} Python-Beispiel (mit requests)
import requests
API_KEY = "dein_api_key_hier"
BASE_URL = "https://api.dify.ai/v1"
def chat(query, conversation_id="", user="nutzer-123"):
response = requests.post(
f"{BASE_URL}/chat-messages",
headers={
"Authorization": f"Bearer {API_KEY}",
"Content-Type": "application/json",
},
json={
"inputs": {},
"query": query,
"response_mode": "blocking",
"conversation_id": conversation_id,
"user": user,
}
)
response.raise_for_status()
return response.json()
# Erste Nachricht
result = chat("Was ist Dify?")
print(result["answer"])
conversation_id = result["conversation_id"]
# Nachfolge in derselben Konversation
result2 = chat("Kannst du das näher erläutern?", conversation_id=conversation_id)
print(result2["answer"]) conversation_id aus der ersten Antwort und übergib sie in Folgeaufrufen. So wird der Gesprächsverlauf beibehalten, und die KI erinnert sich an das Gesagte.
Streaming-Antworten (SSE)
Streaming ermöglicht es, Tokens während der Generierung anzuzeigen — wie der Tipp-Effekt bei ChatGPT. Dify verwendet Server-Sent Events (SSE) für Streaming. Setze "response_mode": "streaming" im Request-Body.
Jedes Event kommt als Zeile mit dem Präfix data: an. Die Event-Typen umfassen message (ein Token-Chunk), message_end (Abschlussnachricht mit Metadaten) und error.
Streaming curl-Beispiel
curl -X POST 'https://api.dify.ai/v1/chat-messages' \
-H 'Authorization: Bearer DEIN_API_KEY' \
-H 'Content-Type: application/json' \
--no-buffer \
-d '{
"inputs": {},
"query": "Schreib ein kurzes Gedicht über KI.",
"response_mode": "streaming",
"conversation_id": "",
"user": "nutzer-123"
}' Python Streaming-Beispiel
import requests
import json
def stream_chat(query, user="nutzer-123"):
with requests.post(
"https://api.dify.ai/v1/chat-messages",
headers={
"Authorization": "Bearer DEIN_API_KEY",
"Content-Type": "application/json",
},
json={
"inputs": {},
"query": query,
"response_mode": "streaming",
"conversation_id": "",
"user": user,
},
stream=True,
) as response:
for line in response.iter_lines():
if line and line.startswith(b"data: "):
data = json.loads(line[6:])
if data.get("event") == "message":
print(data["answer"], end="", flush=True)
elif data.get("event") == "message_end":
print()
break
stream_chat("Erkläre Quantencomputing einfach.") JavaScript / Browser (fetch mit ReadableStream)
async function streamChat(query) {
const response = await fetch("https://api.dify.ai/v1/chat-messages", {
method: "POST",
headers: {
"Authorization": "Bearer DEIN_API_KEY",
"Content-Type": "application/json",
},
body: JSON.stringify({
inputs: {},
query,
response_mode: "streaming",
conversation_id: "",
user: "nutzer-browser",
}),
});
const reader = response.body.getReader();
const decoder = new TextDecoder();
while (true) {
const { done, value } = await reader.read();
if (done) break;
const lines = decoder.decode(value).split("\n");
for (const line of lines) {
if (line.startsWith("data: ")) {
const data = JSON.parse(line.slice(6));
if (data.event === "message") {
document.getElementById("ausgabe").textContent += data.answer;
}
}
}
}
}
streamChat("Was sind die Vorteile von Self-Hosted KI?"); Dify API mit Self-Hosted-Installation
Wenn du Dify auf deinem eigenen Server hostest, funktioniert die API genauso — du ersetzt einfach die Basis-URL. Das ist der Hauptvorteil des Self-Hostings: Du kontrollierst die Infrastruktur, Daten bleiben auf deinem Server, und es gibt keine Limits für Message Credits.
Dify Cloud
BASE_URL = "https://api.dify.ai/v1" Self-Hosted
BASE_URL = "https://dein-server.com/v1" Alles andere — das Format des API-Schlüssels, Request-Bodies, Antwortformat, Streaming — bleibt identisch. Das macht es einfach, gegen Dify Cloud zu entwickeln und dann für die Produktion auf eine Self-Hosted-Instanz umzusteigen, indem man nur eine Umgebungsvariable ändert.
Beste Hosting-Optionen für API-intensive Workloads
Hetzner VPS (Selbstverwaltung)
Ab €3,79/Monat. Bestes Preis-Leistungs-Verhältnis. Ideal für Entwickler, die mit Linux vertraut sind.
Hetzner ansehen →Elestio (Managed)
Verwaltetes Dify-Deployment. Automatische Updates, Backups, SSL. Kein Server-Management nötig.
Elestio ansehen →Häufig gestellte Fragen
Wie bekomme ich einen Dify API-Schlüssel?
Öffne deine Dify-App, klicke oben rechts auf 'API Access' und erstelle einen neuen API-Schlüssel. Kopiere den Secret Key — er wird nur einmal angezeigt. Verwende ihn im Authorization-Header als 'Bearer DEIN_KEY'.
Ist die Dify API kostenlos?
Die Dify API selbst ist kostenlos — du zahlst nur für die verbrauchten LLM-Token (OpenAI, Anthropic usw.). Self-hosted Dify hat keine API-Kosten. Dify Cloud berechnet nach Message Credits.
Kann ich Dify API-Antworten streamen?
Ja. Setze 'response_mode':'streaming' im Request-Body, um Server-Sent Events (SSE) zu erhalten. So kannst du Tokens anzeigen, während sie generiert werden — wie bei ChatGPT.
Welche Programmiersprachen funktionieren mit der Dify API?
Jede Sprache, die HTTP-Requests unterstützt: Python, JavaScript/Node.js, PHP, Ruby, Go, Java, C# und mehr. Dify bietet offizielle SDKs für Python und Node.js sowie curl-Beispiele für jeden Endpunkt.
Bereit, Dify selbst zu hosten?
Hole das Maximum aus der Dify API heraus, indem du selbst hostest: keine Credit-Limits, volle Datenprivatsphäre, eigene Domain und dieselbe API-Schnittstelle. Vergleiche die besten Hosting-Optionen für deine Bedürfnisse.