React Security Scanner
React apps ship security problems that generic scanners miss: source maps left in production expose your full codebase, vulnerable npm packages ship to every visitor's browser, and hardcoded API keys end up in the compiled bundle. Our scanner catches the HTTP-layer risks before attackers do.
Scan My React App. FreeNo signup · No credit card · Scan runs in 60 seconds, verify your email to view results
Rather not remember to rescan? We can scan your site every month and email you the results. See pricing
What the scanner checks
Vulnerable CDN libraries
Reads the script tags on your page. Libraries loaded from a CDN with a version in the URL (unpkg, jsDelivr, cdnjs) are matched against the retire.js vulnerability database. Packages compiled into your own bundle are not visible this way.
Secrets in your repository
The URL scan does not read your bundle. To find keys before they get bundled, run the repository scan at /code on a public GitHub repo: it checks committed secrets, dependencies and risky patterns like dangerouslySetInnerHTML.
Content-Security-Policy present
Checks that your site sends a CSP header at all. It does not grade the policy, so a CSP with 'unsafe-inline' still passes this check. Read the value yourself, or start from the CSP generator.
HTTP security headers
Audits all seven critical security headers: HSTS, X-Content-Type-Options, X-Frame-Options, Referrer-Policy, Permissions-Policy, and Cross-Origin-Opener-Policy. These come from your CDN or server, not React itself.
SSL/TLS and HTTPS enforcement
Checks certificate validity, expiry, protocol version (TLS 1.2+), and whether HTTP traffic is redirected to HTTPS. React apps on expired or self-signed certs break the trust chain for everything above.
React Security Is a Bundle Problem, Not a Framework Problem
React does one thing well: it renders UI safely. The JSX compiler HTML-encodes output by default, and dangerouslySetInnerHTML exists precisely to make developers think twice before bypassing that. What React does not do is control what ends up in your production bundle, what HTTP headers your server sends, or whether your build pipeline strips source maps.
The most common React security failures are not React bugs - they are deployment configuration failures. Source maps stay on (productionSourceMaps: true in Create React App). Environment variables get moved from server config into the bundle (REACT_APP_SECRET prefix). Dependencies accumulate CVEs because npm audit is skipped in CI. None of these require an attacker to exploit React directly - they just require fetching a public URL.
The CVEs that matter most for React in 2026 are in the server-rendering layer, not the client. CVE-2025-55182 (CVSS 10.0) and CVE-2026-23864 affect React Server Functions used by frameworks like Next.js - they do not affect a standard React SPA served as static files. If your app uses server-side rendering or React Server Components, the attack surface expands significantly. Our scanner tests the HTTP boundaries of both. For deep Next.js-specific checks, see the Next.js security scanner.

What a URL scan can see in a React app, and what it can't
Most of what makes a React app risky lives in code that has been compiled, minified and shipped as one file. A scanner that only requests your URL sees roughly what a browser sees before it runs that file. That is still a lot, but it is a different list from the one in most React security articles, so here it is split honestly.
Visible from the URL (this scan):
- Every response header: CSP present or missing, HSTS, X-Frame-Options, nosniff, Referrer-Policy, Permissions-Policy, COOP, and
Server/X-Powered-Byleaks. On a React SPA these come from your host (Vercel, Netlify, Nginx, S3 + CloudFront), not from React, which is why they are so often missing. - Cookies the server sets on the first response, with their flags.
- TLS: certificate validity and whether
http://redirects tohttps://. <script src>tags pointing at a CDN with a version number, for examplehttps://unpkg.com/react@16.4.0/umd/react.production.min.js. Those versions are matched against known vulnerabilities.- 71 paths that should not be public, such as
/.env,/.git/configor/package.json.
Not visible from the URL:
- Anything inside your bundle: API keys inlined through
REACT_APP_orVITE_variables,dangerouslySetInnerHTMLon user content, the versions of packages younpm installed. - Whether source maps are published. Check by appending
.mapto your main bundle URL in the browser. - What your CSP actually allows.
For the second list, scan the code rather than the site. /code takes a public GitHub repository and runs secret, dependency and pattern checks on it. npm audit covers installed package versions locally. If you deploy with Next.js, React Server Components move part of the risk to the server, and the Next.js scanner page covers that side.
Frequently Asked Questions
How do I check if my React app exposes source maps?
Open Chrome DevTools, go to the Sources tab, and look for .map file entries. Or fetch your main bundle URL and append .map - if it returns a JSON file with original source code, it is exposed. Disable source maps in production by setting GENERATE_SOURCEMAP=false in Create React App, or removing the devtool setting in your webpack config.
Can attackers see API keys in my React bundle?
Yes. Anything in the compiled JavaScript is fully visible to anyone who opens DevTools or downloads the file. In Create React App, REACT_APP_ prefixed variables are inlined at build time. In Vite, VITE_ prefixed variables go into the bundle. Store secrets server-side only and expose them through API endpoints that enforce authentication.
What Content-Security-Policy do I need for a React SPA?
At minimum: Content-Security-Policy: default-src 'self'; script-src 'self'; style-src 'self' 'unsafe-inline'; img-src 'self' data: https:. Avoid unsafe-eval entirely. For inline scripts you control, use nonces or hashes instead of unsafe-inline. Tools like CSP Evaluator can validate your policy before deployment.
Does React prevent XSS automatically?
React escapes all string content rendered via JSX by default. The risk is dangerouslySetInnerHTML, which bypasses that escaping. Also watch for: eval() or new Function() with dynamic strings, href={userInput} without URL scheme validation, and using third-party components that pass user data to innerHTML. A strong CSP is your defense in depth against any XSS that slips through.
Should I worry about CVE-2025-55182 in my React app?
CVE-2025-55182 (CVSS 10.0) affects React Server Functions - the server-side endpoint layer used by RSC-capable frameworks like Next.js, React Router v7, and Waku. If your app is a standard client-side SPA (Create React App, Vite without SSR), you are not vulnerable. If you use React with server-side rendering or a framework that supports Server Actions, patch immediately to react@19.0.1 or 19.1.2+.
Why does the scan find no JavaScript libraries on my React app?
Because they are bundled. Vite, webpack and Next.js compile your dependencies into your own JS files, so no CDN URL with a version exists for the scanner to read. That is normal for modern builds. Use npm audit or the repository scan for bundled packages.
Find what your React build left behind
Free, no signup. Verify your email to view the detailed report with fix instructions.
Run Free React Security ScanFree Security Tools
Run individual checks on your React site for free.
Other Stack Scanners
Running more than React? These scanners check stack-specific issues the generic scan does not look for.
Expert Help
Book a security review for your React site
30-minute consultation with a security engineer. Covers your scan results, how to fix critical issues, and what to prioritize. Free, no sales pitch.
Book Free Consultation