Summary
Langflow contained an Insecure Direct Object Reference flaw in the /api/v1/responses endpoint that allowed one authenticated user to trigger flows owned by other users simply by providing their flow IDs.
When multi-tenant deployments reuse common APIs without verifying resource ownership, authenticated attackers can abuse these references to run unauthorized workflows and access data they should not see.
Affected context
The vulnerability arises in Langflow's multi-user environment where flows are stored with unique identifiers and exposed via a shared API.
The /api/v1/responses endpoint accepts a flow ID and executes the corresponding workflow but, in affected versions, does not robustly verify that the requesting user actually owns or is permitted to use that flow.
This becomes risky wherever users can discover or guess other users' flow IDs, such as through logs, shared URLs, or predictable identifiers.
Exploit preconditions
- Attack surface: HTTP API endpoint
/api/v1/responsesexposed to authenticated users. - Required access: Valid account on the Langflow instance (no special privileges required beyond standard user access).
- Trigger point: Submitting a request to
/api/v1/responseswith the flow ID of a victim's workflow instead of the attacker's own. - Why exploitation is possible: The endpoint relied on the provided flow ID alone and did not consistently enforce ownership or access-control checks, allowing cross-tenant execution of another user's flows.
Why this happens
The underlying issue is a classic Insecure Direct Object Reference (CWE-639), where internal identifiers are used directly to access resources without binding them to the authenticated principal.
In this case, the API that executes flows trusts the flow_id parameter and does not confirm that the calling user is authorized to execute the identified flow.
This pattern emerges when authorization logic is incomplete or decoupled from resource resolution, so the system treats any valid identifier as accessible regardless of tenancy or ownership.
Potential impact
- An attacker may execute another user's flows without consent.
- Flows could run with different data sources or credentials, leading to unauthorized data access.
- Attackers can indirectly observe outputs, prompts, or configuration details from victim flows.
- Misuse of victim flows can result in unintended external calls, notifications, or integrations being triggered.
- Compromise of isolation guarantees in multi-tenant or shared Langflow deployments.
General mitigation guidance
Effective mitigation focuses on enforcing strict authorization checks for every resource access.
API handlers should resolve the requested flow in the context of the current user or tenant, ensuring that only flows owned by or explicitly shared with that principal can be executed.
Design APIs so that client-visible identifiers are scoped per user or tenant and avoid predictable global identifiers where possible.
Implement defense-in-depth by centralizing access control, applying least-privilege principles to flows and associated credentials, and reducing reliance on user-supplied IDs without server-side validation.
How teams detect issues like this
Detection typically involves reviewing authorization logic around resource lookups in APIs and ensuring that user identity is always considered when resolving object IDs.
Static analysis and code review can focus on endpoints that accept identifiers (e.g., flow_id) and check whether ownership or permission checks follow each lookup.
Logging and monitoring can be configured to flag unusual patterns, such as users repeatedly attempting to access flows they do not own or sequences of requests referencing many different flow IDs.
Automated security testing and API-focused scanners can exercise endpoints with cross-user identifiers to reveal missing access-control enforcement.

