Aktualisiert März 2026 Entwickler-Guide REST API

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.

Hinweis: Jeder Dify-App-Typ (Chatbot, Agent, Workflow, Completion) hat leicht unterschiedliche Endpunkte. Diese Anleitung konzentriert sich auf die Chat Messages API, die am häufigsten verwendet wird.

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:

1

Ö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.

2

Klicke oben rechts auf "API Access"

Dies öffnet das API-Referenzpanel für genau diese App.

3

Klicke auf "API Key erstellen"

Gib ihm einen Namen (z.B. "produktion" oder "test"), um ihn später zu identifizieren.

4

Kopiere den Secret Key sofort

Der Key wird nur einmal angezeigt. Speichere ihn als Umgebungsvariable — niemals direkt im Quellcode.

5

Verwende ihn im Authorization-Header

Alle API-Anfragen benötigen diesen Header: Authorization: Bearer DEIN_API_KEY

Sicherheitswarnung: Expose deinen API-Schlüssel niemals in clientseitigem JavaScript oder in einem öffentlichen Repository. Speichere ihn immer als Umgebungsvariable und rufe die Dify API immer vom Backend-Server aus auf.

Ü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"])
Tipp: Speichere die 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 →
SSL erforderlich: Stelle sicher, dass dein Self-Hosted Dify über HTTPS erreichbar ist. Die meisten Browser blockieren Mixed-Content-Anfragen von HTTPS-Seiten zu HTTP-APIs. Konfiguriere einen Reverse Proxy (Nginx + Let's Encrypt) für SSL.

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.

Dify Hosting-Optionen vergleichen → Dify Tutorial