Prediction
Prediction API is the primary endpoint for interacting with your Flowise flows and assistants. It allows you to send messages to your selected flow and receive responses back. This API handles the core chat functionality, including:
Chat Interactions: Send questions or messages to your flow and receive AI-generated responses
Streaming Responses: Get real-time streaming responses for better user experience
Conversation Memory: Maintain context across multiple messages within a session
File Processing: Upload and process images, audio, and other files as part of your queries
Dynamic Configuration: Override chatflow settings and pass variables at runtime
For details, see the Prediction Endpoint API Reference.
Base URL and Authentication
Base URL: http://localhost:3000
(or your Flowise instance URL)
Endpoint: POST /api/v1/prediction/:id
Authentication: Refer Authentication for Flows
Request Format
Basic Request Structure
{
"question": "Your message here",
"streaming": false,
"overrideConfig": {},
"history": [],
"uploads": [],
"form": {}
}
Parameters
question
string
Yes
The message/question to send to the flow
form
object
Either question
or form
The form object to send to the flow
streaming
boolean
No
Enable streaming responses (default: false)
overrideConfig
object
No
Override flow configuration
history
array
No
Previous conversation messages
uploads
array
No
Files to upload (images, audio, etc.)
humanInput
object
No
Return human feedback and resume execution
SDK Libraries
Flowise provides official SDKs for Python and TypeScript/JavaScript:
Installation
Python: pip install flowise
TypeScript/JavaScript: npm install flowise-sdk
Python SDK Usage
from flowise import Flowise, PredictionData
# Initialize client
client = Flowise(base_url="http://localhost:3000")
# Non-streaming prediction
try:
response = client.create_prediction(
PredictionData(
chatflowId="your-chatflow-id",
question="What is machine learning?",
streaming=False
)
)
# Handle response
for result in response:
print("Response:", result)
except Exception as e:
print(f"Error: {e}")
TypeScript/JavaScript SDK Usage
import { FlowiseClient } from 'flowise-sdk';
// Initialize client
const client = new FlowiseClient({
baseUrl: 'http://localhost:3000'
});
// Non-streaming prediction
async function chatWithFlow() {
try {
const response = await client.createPrediction({
chatflowId: 'your-chatflow-id',
question: 'What is machine learning?',
streaming: false
});
console.log('Response:', response);
} catch (error) {
console.error('Error:', error);
}
}
chatWithFlow();
Direct HTTP API Usage
If you prefer to use the REST API directly without SDKs:
Basic Request
import requests
import json
def send_message(chatflow_id, question, streaming=False):
url = f"http://localhost:3000/api/v1/prediction/{chatflow_id}"
payload = {
"question": question,
"streaming": streaming
}
headers = {
"Content-Type": "application/json"
}
try:
response = requests.post(url, json=payload, headers=headers)
response.raise_for_status() # Raise exception for bad status codes
return response.json()
except requests.exceptions.RequestException as e:
print(f"Request failed: {e}")
return None
# Usage
result = send_message(
chatflow_id="your-chatflow-id",
question="What is artificial intelligence?",
streaming=False
)
if result:
print("Response:", result)
Advanced Features
Form Input
In Agentflow V2, you can select form
as input type.

You can override the value by Variable Name of the Form Input
{
"form": {
"title": "Example",
"count": 1,
...
}
}
import requests
def prediction(flow_id, form):
url = f"http://localhost:3000/api/v1/prediction/{flow_id}"
payload = {
"form": form
}
try:
response = requests.post(url, json=payload)
response.raise_for_status()
return response.json()
except requests.exceptions.RequestException as e:
print(f"Error: {e}")
return None
result = prediction(
flow_id="your-flow-id",
form={
"title": "ABC",
"choices": "A"
}
)
print(result)
Configuration Override
Override chatflow settings dynamically.
Override config is disabled by default for security reasons. Enable it from the top right: Settings → Configuration → Security tab:

import requests
def query_with_config(flow_id, question, config):
url = f"http://localhost:3000/api/v1/prediction/{flow_id}"
payload = {
"question": question,
"overrideConfig": config
}
try:
response = requests.post(url, json=payload)
response.raise_for_status()
return response.json()
except requests.exceptions.RequestException as e:
print(f"Error: {e}")
return None
# Example: Override session and return source documents
result = query_with_config(
flow_id="your-flow-id",
question="How does machine learning work?",
config={
"sessionId": "user-123",
"temperature": 0.5,
"maxTokens": 1000
}
)
print(result)
For array
type, hovering over the info icon will shows the schema that can be overriden.
Array value from overrideConfig will concatenate with existing array values. For example, if existing startState
has:
{
"key": "key1",
"value": "value1"
}
And if we enable override:

"overrideConfig": {
"startState": [
{
"key": "foo",
"value": "bar"
}
],
"llmMessages": [
{
"role": "system",
"content": "You are helpful assistant"
}
]
}
The final startState
will be:
[
{
"key": "key1",
"value": "value1"
},
{
"key": "foo",
"value": "bar"
},
]
Conversation History
Provide conversation context by including previous messages in the history array.
History Message Format
{
"role": "apiMessage" | "userMessage",
"content": "Message content"
}
import requests
def chat_with_history(flow_id, question, history):
url = f"http://localhost:3000/api/v1/prediction/{flow_id}"
payload = {
"question": question,
"history": history
}
try:
response = requests.post(url, json=payload)
response.raise_for_status()
return response.json()
except requests.exceptions.RequestException as e:
print(f"Error: {e}")
return None
# Example conversation with context
conversation_history = [
{
"role": "apiMessage",
"content": "Hello! I'm an AI assistant. How can I help you today?"
},
{
"role": "userMessage",
"content": "Hi, my name is Sarah and I'm learning about AI"
},
{
"role": "apiMessage",
"content": "Nice to meet you, Sarah! I'd be happy to help you learn about AI. What specific aspects interest you?"
}
]
result = chat_with_history(
flow_id="your-flow-id",
question="Can you explain neural networks in simple terms?",
history=conversation_history
)
print(result)
Session Management
Use sessionId
to maintain conversation state across multiple API calls. Each session maintains its own conversation context and memory.
import requests
class FlowiseSession:
def __init__(self, flow_id, session_id, base_url="http://localhost:3000"):
self.flow_id= flow_id
self.session_id = session_id
self.base_url = base_url
self.url = f"{base_url}/api/v1/prediction/{flow_id}"
def send_message(self, question, **kwargs):
payload = {
"question": question,
"overrideConfig": {
"sessionId": self.session_id,
**kwargs.get("overrideConfig", {})
}
}
# Add any additional parameters
for key, value in kwargs.items():
if key != "overrideConfig":
payload[key] = value
try:
response = requests.post(self.url, json=payload)
response.raise_for_status()
return response.json()
except requests.exceptions.RequestException as e:
print(f"Error: {e}")
return None
# Usage
session = FlowiseSession(
flow_id="your-flow-id",
session_id="user-session-123"
)
# First message
response1 = session.send_message("Hello, my name is John")
print("Response 1:", response1)
# Second message - will remember the previous context
response2 = session.send_message("What's my name?")
print("Response 2:", response2)
Variables
Pass dynamic variables to your flow using the vars
property in overrideConfig
. Variables can be used in your flow to inject dynamic content.
Variables must be created first before you can override it. Refer to Variables
import requests
def send_with_variables(flow_id, question, variables):
url = f"http://localhost:3000/api/v1/prediction/{flow_id}"
payload = {
"question": question,
"overrideConfig": {
"vars": variables
}
}
try:
response = requests.post(url, json=payload)
response.raise_for_status()
return response.json()
except requests.exceptions.RequestException as e:
print(f"Error: {e}")
return None
# Example: Pass user information and preferences
result = send_with_variables(
flow_id="your-flow-id",
question="Create a personalized workout plan",
variables={
"user_name": "Alice",
"fitness_level": "intermediate",
"preferred_duration": "30 minutes",
"equipment": "dumbbells, resistance bands",
"goals": "strength training, flexibility"
}
)
print(result)
Image Uploads
Upload images for visual analysis when your flow supports image processing. Refer to Image for more reference.
Upload Structure:
{
"data": "",
"type": "",
"name": ",
"mime": "
}
Data: Base64 or URL of an image
Type: url
or file
Name: name of the image
Mime: image/png
, image/jpeg
, image/jpg
import requests
import base64
import os
def upload_image(flow_id, question, image_path):
# Read and encode image
with open(image_path, 'rb') as image_file:
encoded_image = base64.b64encode(image_file.read()).decode('utf-8')
# Determine MIME type based on file extension
mime_types = {
'.png': 'image/png',
'.jpg': 'image/jpeg',
'.jpeg': 'image/jpeg',
'.gif': 'image/gif',
'.webp': 'image/webp'
}
file_ext = os.path.splitext(image_path)[1].lower()
mime_type = mime_types.get(file_ext, 'image/png')
url = f"http://localhost:3000/api/v1/prediction/{flow_id}"
payload = {
"question": question,
"uploads": [
{
"data": f"data:{mime_type};base64,{encoded_image}",
"type": "file",
"name": os.path.basename(image_path),
"mime": mime_type
}
]
}
try:
response = requests.post(url, json=payload)
response.raise_for_status()
return response.json()
except requests.exceptions.RequestException as e:
print(f"Error: {e}")
return None
# Example usage
result = upload_image(
flow_id="your-flow-id",
question="Can you describe what you see in this image?",
image_path="path/to/your/image.png"
)
print(result)
Audio Uploads (Speech to Text)
Upload audio files for speech-to-text processing. Refer to Audio for more reference.
Upload Structure:
{
"data": "",
"type": "",
"name": ",
"mime": "
}
Data: Base64 or URL of an audio
Type: url
or file
Name: name of the audio
Mime: audio/mp4
, audio/webm
, audio/wav
, audio/mpeg
import requests
import base64
import os
def upload_audio(flow_id, audio_path, question=None):
# Read and encode audio
with open(audio_path, 'rb') as audio_file:
encoded_audio = base64.b64encode(audio_file.read()).decode('utf-8')
# Determine MIME type based on file extension
mime_types = {
'.webm': 'audio/webm',
'.wav': 'audio/wav',
'.mp3': 'audio/mpeg',
'.m4a': 'audio/mp4'
}
file_ext = os.path.splitext(audio_path)[1].lower()
mime_type = mime_types.get(file_ext, 'audio/webm')
url = f"http://localhost:3000/api/v1/prediction/{flow_id}"
payload = {
"uploads": [
{
"data": f"data:{mime_type};base64,{encoded_audio}",
"type": "audio",
"name": os.path.basename(audio_path),
"mime": mime_type
}
]
}
# Add question if provided
if question:
payload["question"] = question
try:
response = requests.post(url, json=payload)
response.raise_for_status()
return response.json()
except requests.exceptions.RequestException as e:
print(f"Error: {e}")
return None
# Example usage
result = upload_audio(
flow_id="your-flow-id",
audio_path="path/to/your/audio.wav",
question="Please transcribe this audio and summarize the content"
)
print(result)
File Uploads
Upload files to have LLM process the files and answer query related to the files. Refer to Files for more reference.
Human Input
To resume the execution from a previously stopped checkpoint, humanInput
needs to be provided. Refer Human In The Loop for details.
Human Input Structure
{
"type": "",
"feedback": ""
}
type: Either
proceed
orreject
feedback: Feedback to the last output
Must specify the same sessionId
where the execution was stopped
{
"humanInput": {
"type": "reject",
"feedback": "Include more emoji"
},
"overrideConfig": {
"sessionId": "abc"
}
}
Troubleshooting
404 Not Found: Verify the flow ID is correct and the flow exists
401 Unauthorized Access: Verify if the flow is API key protected
400 Bad Request: Check request format and required fields
413 Payload Too Large: Reduce file sizes or split large requests
500 Internal Server Error: Check if there is any misconfiguration from the nodes in the flow
Last updated