Summary
Flowise's HTTP Node in AgentFlow and Chatflow can be configured with user-controlled URLs, allowing server-side HTTP requests to arbitrary destinations without host restrictions.
When a chatflow is exposed publicly, any user can abuse this behavior to coerce the Flowise server into making requests to internal or otherwise non-public network resources.
Affected context
This vulnerability appears in Flowise deployments that:
- Use AgentFlow or Chatflow configurations including the HTTP Node
- Allow user-controlled or user-influenced URLs to be sent to the HTTP Node
- Expose chatflows or agents over the internet without strict network egress controls
In such setups, the Flowise server can be abused as an HTTP proxy to reach internal networks, localhost services, or cloud metadata endpoints that would not normally be reachable from the public internet.
Exploit preconditions
- Attack surface: Publicly accessible Flowise chatflows or AgentFlows that include an HTTP Node.
- Required access: Ability to interact with a chatflow or agent (e.g., send messages or parameters that influence the requested URL); no direct server access is needed.
- Trigger point: The moment the HTTP Node processes a request using a URL that is directly or indirectly controlled by the user.
- Why exploitation is possible: The HTTP Node performs server-side HTTP requests without validating or restricting destination hosts, allowing requests to private IP ranges, localhost, and metadata services.
Why this happens
The core issue stems from treating user-controlled URLs as fully trusted destinations for server-side HTTP requests.
The HTTP Node functions as a generic outbound HTTP client but lacks host validation, network segmentation awareness, or allow/deny lists.
This maps to CWE-918: Server-Side Request Forgery (SSRF), where a server-side component is tricked into initiating network requests to arbitrary internal or external systems on behalf of an attacker.
Conceptually, the bug class is an over-privileged server-side fetch primitive combined with untrusted input, turning normal HTTP integrations into a network pivot point.
Potential impact
- Unauthorized access to internal web services, APIs, or admin interfaces that are not exposed to the internet
- Interaction with cloud metadata endpoints, which can lead to credential exposure or environment data leakage
- Network scanning of internal hosts and ports using the Flowise server as a vantage point
- Bypassing IP-based access controls and firewalls that trust the Flowise server's network location
- Potential chaining with other vulnerabilities on internal services (e.g., exploiting internal-only admin panels)
General mitigation guidance
Effective mitigation focuses on reducing the trust boundary of outbound HTTP requests and constraining where the HTTP Node can connect.
Useful defensive patterns include:
- Implementing strict allowlists for outbound destinations, limiting the HTTP Node to known, external, HTTPS endpoints
- Blocking requests to private and link-local address ranges (e.g., RFC 1918, 127.0.0.0/8, 169.254.169.254, ::1) and other non-routable spaces
- Disallowing or normalizing user-controlled URLs, such as forcing selection from a curated set of base endpoints instead of free-form URLs
- Enforcing application-layer validation on URLs (scheme, hostname, port) before initiating requests
- Running Flowise with network egress controls at the infrastructure level (e.g., firewalls, outbound proxies, Kubernetes network policies) to segment access to sensitive internal resources
- Applying least privilege to any credentials used by Flowise when calling upstream services, minimizing the blast radius of any SSRF attempt
How teams detect issues like this
Detection can rely on both code-centric and runtime-centric approaches:
- Static analysis & review:
- Search for HTTP client usage within nodes that consume user-controlled URLs (e.g., generic fetch/http request utilities).
- Flag patterns where URLs are taken from request payloads, chat parameters, or configuration fields without host validation or filtering.
- Review node configuration schemas for fields that accept arbitrary URLs and verify whether they are constrained.
- Policy enforcement:
- Introduce coding guidelines that require allowlists or host validation for all outbound HTTP nodes.
- Use CI checks or linters to detect unbounded URL usage in extension nodes or custom connectors.
- Runtime monitoring:
- Monitor Flowise server outbound network traffic, especially connections to private ranges, localhost, or cloud metadata IPs.
- Configure intrusion detection systems or network logs to alert on unusual outbound destinations from the Flowise host.
- Automated SAST/DAST tools can be used to identify SSRF patterns, but results should always be validated through manual review to understand the actual risk.

