Langflow (1.13.0)

List the caller's own A2A-published agent flows, each with its agent-card URL.

Authenticated and owner-scoped, mirroring the MCP-projects catalog: a public cross-user directory would strip the per-flow card's unguessable-id obscurity and expose other users' agents, so this enumerates only the calling user's agents. Each cardUrl is the public discovery entry point an orchestrator fetches per agent.

Serve the spec-valid A2A agent card for an agent-typed, a2a_enabled flow.

Public by design: the A2A public agent card is unauthenticated by spec, so gating it behind login would break standard discovery. Returns 404 when the flag is off, the flow does not exist, the flow is not flow_type=agent, or a2a_enabled is falsy.

Serve the A2A JSON-RPC surface (message/send, message/stream, tasks/get, tasks/resubscribe) for an agent flow.

Gated like the card route; apikey-folder flows additionally require a valid owner key (401). The flow runs as its owner. Returns the SDK's JSON-RPC response (HTTP 200 even for JSON-RPC-level errors). No DbSession dependency here: holding a session open across the run would fight the v2 surface's lock-avoidance design, and the gate/run resolve from flow_id via short self-managed sessions.

Retrieve all component types with compression for better performance.

Returns a compressed response containing all available component types, with display_names translated to the locale indicated by Accept-Language.

Retrieve application configuration settings.

Returns different configuration based on authentication status:

• Authenticated users: Full ConfigResponse with all settings
• Unauthenticated users: PublicConfigResponse with limited, safe-to-expose settings

Args: user: The authenticated user, or None if unauthenticated.

Returns: ConfigResponse | PublicConfigResponse: Configuration settings appropriate for the user's auth status.

Raises: HTTPException: If an error occurs while retrieving the configuration.

Executes a specified flow by ID with optional input values, output selection, tweaks, and streaming capability.

This endpoint supports running flows with caching to enhance performance and efficiency.

Parameters:

• flow (Flow): The flow object to be executed, resolved via dependency injection.
• inputs (List[InputValueRequest], optional): A list of inputs specifying the input values and components for the flow. Each input can target specific components and provide custom values.
• outputs (List[str], optional): A list of output names to retrieve from the executed flow. If not provided, all outputs are returned.
• tweaks (Optional[Tweaks], optional): A dictionary of tweaks to customize the flow execution. The tweaks can be used to modify the flow's parameters and components. Tweaks can be overridden by the input values.
• stream (bool, optional): Specifies whether the results should be streamed. Defaults to False.
• session_id (Union[None, str], optional): An optional session ID to utilize existing session data for the flow execution.
• api_key_user (User): The user associated with the current API key. Automatically resolved from the API key.

Returns:

A RunResponse object containing the selected outputs (or all if not specified) of the executed flow and the session ID. The structure of the response accommodates multiple inputs, providing a nested list of outputs for each input.

Raises:

HTTPException: Indicates issues with finding the specified flow, invalid input formats, or internal errors during flow execution.

Example usage:

POST /run/flow_id
x-api-key: YOUR_API_KEY
Payload:
{
    "inputs": [
        {"components": ["component1"], "input_value": "value1"},
        {"components": ["component3"], "input_value": "value2"}
    ],
    "outputs": ["Component Name", "component_id"],
    "tweaks": {"parameter_name": "value", "Component Name": {"parameter_name": "value"}, "component_id": {"parameter_name": "value"}}
    "stream": false
}

This endpoint facilitates complex flow executions with customized inputs, outputs, and configurations, catering to diverse application requirements.

Executes a specified flow by ID with support for streaming and telemetry (API key auth).

This endpoint executes a flow identified by ID or name, with options for streaming the response and tracking execution metrics. It handles both streaming and non-streaming execution modes. This endpoint uses API key authentication (Bearer token).

Args: background_tasks (BackgroundTasks): FastAPI background task manager flow (FlowRead | None): The flow to execute, loaded via dependency input_request (SimplifiedAPIRequest | None): Input parameters for the flow stream (bool): Whether to stream the response api_key_user (UserRead): Authenticated user from API key context (dict | None): Optional context to pass to the flow http_request (Request): The incoming HTTP request for extracting global variables

Returns: Union[StreamingResponse, RunResponse]: Either a streaming response for real-time results or a RunResponse with the complete execution results

Raises: HTTPException: For flow not found (404) or invalid input (400) APIException: For internal execution errors (500)

Notes: - Supports both streaming and non-streaming execution modes - Tracks execution time and success/failure via telemetry - Handles graceful client disconnection in streaming mode - Provides detailed error handling with appropriate HTTP status codes - Extracts global variables from HTTP headers with prefix X-LANGFLOW-GLOBAL-VAR-* - Merges extracted variables with the context parameter as "request_variables" - In streaming mode, uses EventManager to handle events: - "add_message": New messages during execution - "token": Individual tokens during streaming - "end": Final execution result - Authentication: Requires API key (Bearer token)

Run a flow using a webhook request.

Args: auth: Resolved webhook user and flow, scoped to the authenticated caller. request: The incoming HTTP request.

Returns: A dictionary containing the status of the task.

Raises: HTTPException: If the flow is not found or if there is an error processing the request.

Every audit event, newest first, filtered and keyset-paginated on the server.

Filters: source, kind, resource_type, action, exclude_action, operation, result and actor_type repeat and OR within themselves; resource_id, user_id, actor_id, request_id, since and until narrow further. q keeps rows whose action, operation, resource type or name, actor username or details contain it, ignoring case. include_total=true adds a count of every match. offset jumps to a page by position instead of a cursor; next_cursor then continues from it.

Stream every matching event as CSV (default) or NDJSON, newest first.

The window is frozen when the export starts, so it is one consistent snapshot however long it runs, and the rows are never gathered in memory.

Return caller-specific administration access and installed features.

List role assignments scoped to one user.

• Omitting user_id defaults to the caller — no superuser needed.
• Passing user_id == self.id is the same as omitting it.
• Passing a different user_id requires role:manage; otherwise 403.

Results are always filtered by the resolved user_id. Admins who need cross-user lookups make one call per user. Paginated via limit / offset (default 100, max 200).

Assign a role to a user as a role administrator.

Remove a manual grant, returning the assignment when another source preserves it.

List roles. Open to authenticated users so the UI can populate dropdowns.

Paginated via limit / offset so a single call cannot return the entire catalog of roles + their permissions. Stable order is (name, id) so offset is deterministic across calls.

Create a custom (non-system) role.

Delete a custom role.

System roles cannot be deleted; roles with active assignments return 409 (delete the assignments first).

Update fields on a custom role. System roles are read-only.

List teams. Open to any authenticated user (for the share dialog's team picker).

Paginated via limit / offset so a single call cannot enumerate every team. Stable order is (team_name, id) so offset is deterministic.

List members of a team. Any authenticated user (so the UI can render team rosters).

Paginated via limit / offset so a single call cannot enumerate a large team's full roster. Stable order is (created_at, user_id).

HTTP entry point for the v1 build route: always the interactive_chat family.

The execution family is deliberately NOT a request parameter. It selects the identity connections resolve under, so a caller able to name it could ask for webhook and run under the flow owner's credentials.

Cancel a specific build job.

Requires authentication and ownership verification to prevent a user from aborting another user's running build (DoS via job cancellation). Jobs started via build_public_tmp are explicitly marked public. Jobs without a queue owner or public marker return 404.

Get events for a specific build job.

Requires authentication and ownership verification. A job owner is registered when build_flow is called; if a registered owner does not match the requesting user the endpoint returns 404 to avoid leaking job existence. Jobs started via build_public_tmp are explicitly marked public. Jobs without a queue owner or public marker return 404.

Build a public flow without requiring authentication.

This endpoint is specifically for public flows that don't require authentication. It uses a client_id cookie to create a deterministic flow ID for tracking purposes.

Security Note:

• The 'data' parameter is NOT accepted to prevent flow definition tampering
• Public flows must execute the stored flow definition only
• The flow definition is always loaded from the database
• Caller-supplied 'inputs.session' is namespaced under the (client_id, flow_id) virtual flow ID so an unauthenticated caller cannot address a session that lives outside its own namespace (CVE-2026-33017)

The endpoint:

1. Verifies the requested flow is marked as public in the database
2. Creates a deterministic UUID based on client_id and flow_id
3. Uses a stable anonymous principal to build the flow
4. Always loads the flow definition from the database

Requirements:

• The flow must be marked as PUBLIC in the database
• The request must include a client_id cookie

Args: flow_id: UUID of the public flow to build background_tasks: Background tasks manager inputs: Optional input values for the flow files: Optional files to include stop_component_id: Optional ID of component to stop at start_component_id: Optional ID of component to start from log_builds: Whether to log the build process flow_name: Optional name for the flow request: FastAPI request object (needed for cookie access) queue_service: Queue service for job management authenticated_user: Optional authenticated user (resolved from cookie/token if present) event_delivery: Optional event delivery type - default is streaming

Returns: Dict with job_id that can be used to poll for build status

Cancel a public flow build job.

This endpoint does not require authentication, matching the public build endpoint. It is used by the shareable playground to cancel builds.

Get events for a public flow build job.

This endpoint does not require authentication, matching the public build endpoint. It is used by the shareable playground to consume build events.

Return the complete global component block set.

Replace the complete global component block set.