/

CVE-2026-32857

Severity:

HIGH RISK

(8.6)

SSRF in Firecrawl Playwright Scraping Service

CVE-2026-32857

Deferred

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-918

Impact:

Unauthorized access to internal network resources and sensitive endpoints via SSRF

Severity:

HIGH RISK

(8.6)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

Summary

Firecrawl up to version 2.8.0 contains a server-side request forgery (SSRF) protection bypass in its Playwright-based scraping service, where URL validation is applied only to the initial user-supplied URL but not to redirect targets.

An attacker can supply a seemingly benign URL that passes network policy checks yet redirects to internal or otherwise restricted endpoints, allowing the service to access internal network resources and sensitive services on the attacker's behalf.

Affected context

This vulnerability affects Firecrawl deployments that:

  • Expose the Playwright-powered scraping service to user-controlled URLs
  • Rely on network policy or URL validation to restrict access to internal or sensitive endpoints
  • Allow the browser automation engine to automatically follow HTTP redirects

The issue manifests specifically when the system validates only the initial user-supplied URL and does not re-apply the same network policy checks to each redirect destination that the browser follows.

Exploit preconditions

  • Attack surface: Remote web/API interface where users can request Firecrawl to scrape arbitrary URLs using the Playwright service.
  • Required access: Ability to submit or influence the URL that Firecrawl's scraper will fetch (e.g., an API call, web form field, or integration input).
  • Trigger point: The scraper issues an HTTP request to the attacker-controlled initial URL, which responds with an HTTP redirect (e.g., 30x) to an internal or restricted target.
  • Why exploitation is possible: The SSRF protection and network policy checks are applied only to the initial URL; redirect locations are not revalidated. As a result, a redirect chain can terminate at internal IPs, cloud metadata endpoints, or other restricted services, allowing the Playwright browser to reach them from within the deployment's network boundary.

Why this happens

The core issue is an incomplete SSRF mitigation pattern where network policy validation is bound to the first outbound request but not to subsequent redirects.

In SSRF-prone systems, any server-controlled HTTP client (such as a headless browser) that accepts user-supplied URLs must treat all request hops—initial request and redirects—as untrusted. In this case, Firecrawl validates the initial user-supplied URL against its network policy, but once a redirect response is received, the browser follows the redirect without re-applying the same checks to the new target URL.

This maps to CWE-918: Server-Side Request Forgery (SSRF), with the specific insecure pattern being a post-redirect enforcement gap: the protection is narrowly scoped to the initial URL rather than the complete request chain, creating an implicit trust in redirect destinations that can be attacker-controlled.

Potential impact

  • Access to internal HTTP services that are not directly exposed to the internet
  • Interaction with cloud provider metadata services or internal management endpoints
  • Enumeration of internal network structure and reachable services
  • Potential access to sensitive configuration data or credentials exposed via internal APIs
  • Use of the Firecrawl environment as a pivot point for further attacks within the infrastructure

General mitigation guidance

Effective mitigation focuses on treating the entire HTTP request chain as untrusted, not just the initial URL.

Recommended defensive patterns include:

  • Enforcing network and URL allowlisting on every outbound request, including all redirect destinations and intermediate hops.
  • Normalizing and revalidating each resolved URL after redirects, with checks against:
  • Private and link-local IP ranges
  • Loopback and host-local addresses
  • Cloud metadata IPs and other high-value internal targets
  • Restricting the scraping service's network egress using firewall rules, service meshes, or container-level network policies, so it can only reach explicitly approved hosts.
  • Decoupling user-controlled URLs from highly privileged network locations by running the scraping engine in a segmented, least-privilege network zone.
  • Applying strict timeouts, redirects limits, and protocol restrictions (e.g., only HTTP/HTTPS) to reduce abuse surface.

How teams detect issues like this

Detection approaches typically aim to identify both the design flaw and concrete abuse patterns:

  • Static analysis and code review:
  • Look for HTTP client usage (including Playwright or browser automation) where user-supplied URLs are fetched.
  • Verify that network policy or validation functions are invoked for every redirect target, not just the first URL.
  • Flag patterns where redirect-following is enabled by default but validation is only applied once.
  • Configuration and policy checks:
  • Ensure outbound egress from scraping components is constrained to expected domains or CIDR ranges.
  • Use security policies (e.g., in service mesh or firewall configuration) to block access to internal and metadata IP ranges from high-risk services.
  • Runtime monitoring:
  • Monitor scraper-originated traffic for requests to internal IP ranges, metadata endpoints, or unexpected ports.
  • Log and alert on outbound redirect chains that end in restricted networks or uncommon destinations.

Automated SAST/IAST tools and security-focused CI checks can help flag SSRF-prone patterns and missing redirect validation before deployment.

Sources

SourceLink
github.comgithub.com/firecrawl/firecrawl/security/advisories/GHSA-vjp8-2wgg-p734
firecrawl.devfirecrawl.dev/
vulncheck.comvulncheck.com/advisories/firecrawl-playwright-service-ssrf-protection-bypass-via-missing-post-redirect-validation

Frequently asked

questions

Yes. If a remote user or integration can supply URLs to the Firecrawl Playwright scraping service, they can potentially exploit this issue by hosting a redirecting endpoint that sends the scraper into internal or restricted addresses.

It depends on how Firecrawl is deployed. If the scraping API or interface is behind authentication, an attacker would need at least that level of access. However, any party capable of influencing the scraped URL—directly or via an integrated system—can attempt to exploit the redirect-based SSRF gap.

The safest pattern is to enforce consistent network and URL validation for every outbound request, including all redirects, combined with strong network egress restrictions so that scraping components can only reach explicitly approved hosts and networks.

Treat all user-influenced outbound requests as untrusted; design HTTP clients so that redirect handling, DNS resolution, and IP evaluation are all subject to the same security policy. Complement application-level checks with defense-in-depth measures such as network segmentation, allowlisting, and continuous security review of components that perform server-side fetching.

Find out what's already
exploitable in your codebase.