Summary
Flowise API Chain components previously contained a Server-Side Request Forgery (SSRF) flaw that allowed crafted prompt templates to make the server initiate arbitrary HTTP requests.
An unauthenticated attacker could abuse these components to reach internal or otherwise restricted endpoints, enabling internal network probing and possible data exfiltration.
Affected context
This vulnerability occurs in Flowise deployments that expose the POST/GET API Chain components and allow user-controlled prompt templates to influence outbound HTTP requests.
It is especially relevant when the Flowise server:
- Has network connectivity to internal services, metadata endpoints, or other sensitive infrastructure
- Runs with permissions that allow access to protected APIs or internal-only hosts
- Does not enforce strict allowlists or hostname/IP validation on API Chain destinations
In such contexts, untrusted users can indirectly control where the server sends HTTP requests.
Exploit preconditions
- Attack surface: Public or semi-public Flowise instances exposing API Chain components over HTTP(S)
- Required access: Ability to submit or influence prompt templates used by POST/GET API Chain nodes; no authentication may be required in some setups
- Trigger point: Execution of an API Chain flow where the destination URL or request parameters are derived from attacker-controlled prompt content
- Why exploitation is possible: The server trusts user-influenced prompt data when constructing outbound HTTP requests, without robust validation or restriction on target hosts, schemes, or paths.
Why this happens
The root cause aligns with CWE-918: Server-Side Request Forgery (SSRF).
The API Chain components combine user-controlled prompt templates with HTTP request logic in a way that allows users to override or bypass intended API documentation constraints.
Instead of treating prompts as untrusted data, the system implicitly trusts their content when forming request URLs or endpoints, providing a channel for attackers to redirect server-initiated requests to arbitrary internal or external resources.
This pattern reflects a lack of strict outbound request validation, insufficient separation between user input and network control logic, and missing network-layer defense-in-depth such as allowlists or network egress controls.
Potential impact
- Internal network reconnaissance, including discovery of internal hosts, ports, and services accessible from the Flowise server
- Access to internal HTTP-based administrative panels, dashboards, or configuration services that are not exposed externally
- Retrieval of sensitive data from internal APIs, metadata services, or private backend endpoints
- Use of the Flowise server as a pivot point for further attacks within the infrastructure
- Interaction with external services in ways that could be used for data exfiltration or abuse of third-party APIs
General mitigation guidance
Effective mitigation focuses on constraining server-initiated HTTP requests and reducing trust in user-controlled prompts:
- Introduce strict allowlists for outbound HTTP targets that API Chains can reach (hostnames, IP ranges, and schemes).
- Validate and sanitize all user-controlled values that influence URLs or network destinations, blocking direct control over protocol, host, and port.
- Separate the concept of "prompt content" from "network configuration" so that user text cannot override documented API endpoints or base URLs.
- Apply network-level egress controls (firewalls, service mesh policies, VPC security rules) to prevent the Flowise server from reaching internal or highly sensitive infrastructure unnecessarily.
- Run Flowise with least-privilege network access and credentials, ensuring it cannot access high-value internal services except where strictly needed.
- Prefer secure, high-level API client abstractions that encapsulate fixed endpoints over generic HTTP clients that accept user-derived URLs.
How teams detect issues like this
Useful detection approaches include:
- Static analysis rules or linters that flag dynamic URL construction in API Chain code paths where values are derived from prompts or other untrusted fields.
- Code review checklists that require explicit outbound request validation, host allowlisting, and clear separation between user input and network configuration.
- Runtime monitoring of outbound HTTP traffic from Flowise instances, with alerts for connections to unexpected internal IP ranges, metadata endpoints, or non-standard ports.
- Web application firewall (WAF) or API gateway policies that inspect and constrain request parameters used by API Chain endpoints, especially those controlling URLs or hosts.
- Periodic security tests and SSRF-focused penetration testing targeting exposed Flowise flows to validate that internal resources cannot be reached from user-controllable inputs.

