Summary
Certain self-hosted Metabase instances that allow users to create subscriptions can be abused to make the server issue HTTP requests to other services it can reach.
When Metabase is colocated with other unsecured internal resources, an attacker may pivot through the Metabase server to interact with those resources via server-side request forgery (SSRF).
Affected context
This vulnerability affects self-hosted Metabase installations where:
- Users are allowed to create or manage subscriptions (for example, email or webhook-based dashboard/report deliveries).
- The Metabase server is deployed in an environment that is colocated with other internal or otherwise unsecured resources, such as internal APIs, admin panels, metadata services, or cloud control endpoints.
- Network controls primarily trust traffic originating from the Metabase host or local network segments.
Under these conditions, subscription features can be misused to direct the Metabase server to initiate outbound requests to targets that are not directly reachable from the attacker's own network.
Exploit preconditions
- Attack surface: Metabase's subscription creation or management interfaces in self-hosted deployments.
- Required access: Ability to authenticate and create or modify subscriptions, or access to any exposed interface that accepts subscription destination details.
- Network layout: Metabase must have network-level reachability to internal or colocated services that are not exposed to the public Internet, and those services must lack sufficient authentication or request validation.
- Trigger point: The moment a subscription runs (e.g., scheduled dashboard delivery) or when Metabase processes the subscription's delivery endpoint or resource reference.
- Why exploitation is possible: The subscription mechanism can be influenced to cause Metabase to send server-side HTTP(S) requests, and insufficient validation or restriction on target addresses or protocols enables SSRF-style abuse.
Why this happens
The core issue maps to CWE-918: Server-Side Request Forgery (SSRF), where a backend component is tricked into making arbitrary network requests on behalf of an attacker.
In this case, subscription functionality implicitly trusts user-supplied or user-controlled configuration (such as endpoints or locations to contact) and uses the Metabase server's own network position and credentials to perform requests.
Without rigorous validation of destination addresses, schemes, and resource scopes—and without strict separation between user-controlled configuration and internal network access—an attacker can coerce the server into acting as a proxy into otherwise inaccessible network zones.
Potential impact
- Unauthorized interaction with internal or colocated services that are not exposed externally.
- Access to sensitive configuration or operational metadata from internal endpoints.
- Abuse of internal HTTP APIs to manipulate data, trigger administrative actions, or reconfigure services.
- Use of Metabase as a pivot point for network reconnaissance inside the hosting environment.
- Potential chaining with other weaknesses in internal services, leading to broader compromise.
General mitigation guidance
Effective mitigation centers on reducing trust in user-controlled network destinations and hardening network boundaries:
- Apply strict allowlists for outbound network requests originating from subscription or reporting features, limiting them to known-safe domains or services.
- Block or strongly restrict access from Metabase to sensitive internal infrastructure (e.g., metadata services, control plane APIs, admin interfaces) at the network layer using firewall rules or service mesh policies.
- Introduce robust URL and address validation in subscription configuration paths, rejecting private IP ranges, link-local addresses, and non-HTTP(S) schemes where not explicitly required.
- Separate Metabase from highly sensitive systems using network segmentation, ensuring that compromise or misuse of Metabase cannot directly reach critical management or data services.
- Run Metabase with least-privilege network and identity permissions, avoiding default access to high-privilege cloud or platform control endpoints.
How teams detect issues like this
High-level detection practices for this class of SSRF risk include:
- Reviewing application code paths where user-controlled configuration (such as subscription endpoints or hooks) is used to construct outbound HTTP requests, paying attention to missing or weak validation of hostnames, IPs, and protocols.
- Using static analysis to flag generic HTTP client usage that consumes user-supplied URLs without filtering for internal IP ranges or disallowed schemes.
- Implementing logging and monitoring of outbound requests from Metabase, with alerts for connections to unexpected RFC1918 or link-local addresses, cloud metadata IPs, or internal-only domain names.
- Enforcing security policies in infrastructure-as-code or deployment tooling that restrict egress access from Metabase pods/hosts to only those destinations required for normal operation.
- Periodically conducting network-level tests or red-team style exercises to verify that application features like subscriptions cannot be abused as SSRF channels.

