Summary
Flowise versions prior to 3.1.0 expose full chatflow objects, including sensitive configuration, through public endpoints without sanitization.
When public chatflows or chatbot configurations are accessed, the API may disclose credential identifiers, plaintext API keys, and password-like fields to any party with the URL, creating a significant risk of account takeover and unauthorized access to external services.
Affected context
This vulnerability affects Flowise deployments that:
- Use versions prior to 3.1.0 (including the v3.0.13 Docker image),
- Enable or rely on "public" chatflows and/or public chatbot configuration endpoints, and
- Store secrets (such as API keys, credential IDs, or password-type values) inside chatflow configuration (flowData).
In these environments, the GET /api/v1/public-chatflows/:id and related public-chatbotConfig endpoints return the complete flowData objects without removing or masking sensitive fields, turning public sharing of chatflows into an unintentional secret exposure channel.
Exploit preconditions
- Attack surface: HTTP(S) public endpoints:
GET /api/v1/public-chatflows/:id- Public chatbot configuration endpoints (e.g., public-chatbotConfig).
- Required access: Ability to reach the public Flowise instance and know or discover a valid public chatflow ID or chatbot identifier. No authentication is required when endpoints are configured as public.
- Trigger point: Any HTTP GET request to the affected public endpoints for a configured public chatflow or chatbot.
- Why exploitation is possible: The backend returns raw flowData objects and related configuration structures without invoking a sanitization routine (the
sanitizeFlowDataForPublicEndpointfunction is absent in v3.0.13), causing secrets embedded in configuration to be included in API responses.
Why this happens
The underlying defect is a missing data sanitization step for structures exposed through public APIs.
Rather than separating internal configuration (which includes secrets) from public metadata, Flowise reuses the same flowData object for both internal use and public sharing.
In affected versions, the intended sanitization function is either absent or not applied, so fields meant to remain confidential (e.g., credential IDs, plaintext API keys, password-type fields) are serialized directly into public responses.
This behavior maps to CWE-200: Information Exposure, where a system inadvertently provides sensitive information to actors who should not have access due to incomplete access control and inadequate output filtering.
Potential impact
- Exposure of plaintext API keys used by the chatflows (e.g., for LLM providers, vector stores, or other integrations).
- Disclosure of password-type configuration fields, enabling unauthorized login to dependent services.
- Leakage of credential IDs and related secrets that can be combined with other information to escalate access.
- Abuse of exposed keys to perform arbitrary operations on connected services (e.g., issuing LLM queries, accessing data stores, or invoking third-party APIs).
- Facilitation of account takeover, data exfiltration, and potential financial impact (e.g., cloud usage costs) through misuse of compromised credentials.
General mitigation guidance
Mitigation approaches generally focus on separating secrets from public objects and ensuring only non-sensitive data is ever exposed via public endpoints.
Common defensive patterns include:
- Designing public APIs to work on derived, sanitized representations of internal models, ensuring confidential fields are never part of the response schema.
- Implementing robust output filtering for any endpoint that can be accessed without strong authentication, explicitly enumerating which fields are allowed to be returned.
- Storing API keys, passwords, and other secrets in dedicated secret stores or environment variables instead of embedding them directly in user-editable flow configuration.
- Applying role-based access control (RBAC) to endpoints, limiting which data is exposed to anonymous users versus authenticated administrators.
- Providing safe-by-default configurations, where new public sharing features exclude sensitive fields unless explicitly whitelisted by maintainers.
How teams detect issues like this
Detection typically relies on a combination of configuration review and automated checks:
- Static and dynamic API response inspection: Regularly inspect and test public endpoints for the presence of secrets or credential-like patterns (e.g., API key formats, tokens, or password fields) in JSON responses.
- Code review signals: Identify controllers or routes serving "public" resources and verify they use explicit sanitization or response DTOs that omit sensitive fields.
- Security testing in CI/CD: Integrate automated tests or DAST tools that crawl public endpoints and flag responses containing patterns that resemble secrets (such as high-entropy strings, known provider key prefixes, or fields named
apiKey,secret,password, etc.). - Policy enforcement: Define development guidelines that prohibit direct serialization of internal configuration objects to HTTP responses, and enforce these via linting rules or internal code review checklists.

