Web Content Vulnerability Scanner
Scan page content for XSS sinks, reflected parameters, open redirects, and mixed content: the injection surface that lives in the HTML and JavaScript a page actually ships.
Critical15High43Medium44Low36Info6
Critical15 checks
- JWT Token Exposed in URLA JSON Web Token was found embedded in a URL within the page HTML.
- AWS Metadata Endpoint ReferenceReference to AWS metadata endpoint (169.254.169.254) detected.
- .env File Reference DetectedReferences to .env file found in page source.
- phpinfo() Page Exposedphpinfo() page or reference detected.
- Password in GET Request URLPassword parameter found in URL.
- Credit Card Number PatternA Luhn-valid number carrying a card-network prefix appears in the page source next to payment vocabulary: a card-number label, a billing or checkout field, CVV, or an expiry date. Luhn is a single check digit, so a card-shaped number with no payment context (an order reference, a tracking number, a row of figures in a table) is not reported.
- SSN Pattern DetectedSocial Security Number pattern in content.
- AWS Credentials Pattern DetectedAWS access key pattern found in source.
- Private Key Detected in SourcePrivate key pattern found in page.
- GitHub Token Pattern DetectedGitHub personal access token found.
- Heroku API Key ExposedHeroku API key pattern found.
- SVG with external entity reference (XXE)An <svg> with an external entity reference like <!ENTITY xxe SYSTEM "file:///..."> can leak local files when the SVG is rendered server-side.
- Django debug page exposing settings and installed appsDjango's DEBUG = True is enabled in production, exposing detailed error pages with source code, local variables, and settings.
- Laravel debug mode enabled in productionLaravel's APP_DEBUG=true is enabled in production, showing detailed error pages with application code, stack traces, and environment variables.
- Database connection string in sourceA database connection string containing credentials is visible in client-accessible source or configuration files.
High43 checks
- Directory Listing Appears EnabledThe response contains patterns indicating directory listing is enabled.
- Potentially Outdated JavaScript LibrariesThe page references JavaScript libraries that are either below a version with known security vulnerabilities, or are deprecated/in maintenance mode with no further security patches.
- Debug Mode or Error Information ExposedDebug/error indicators that reveal internal application details detected.
- Authentication Tokens Exposed in Page SourceTokens or session identifiers exposed in the HTML source.
- Insecure Base Tag DetectedThe page uses a <base> tag with an HTTP URL, making all relative URLs resolve insecurely.
- Dangerous HTML Attributes DetectedPotentially dangerous HTML attributes like inline event handlers, javascript: URIs.
- Deprecated Cipher or Hash Algorithm in Page CodeWeak or broken cryptographic algorithms in client-side JavaScript.
- Potential Server-Side Request Forgery (SSRF) VectorsUser-controlled input may be used in server-side HTTP requests.
- .git Directory Paths Exposed.git directory paths found in page source.
- Spring Boot Actuator Endpoints ExposedSpring Boot Actuator endpoints found in page source.
- postMessage() With Wildcard OriginpostMessage called with * origin target.
- JWT Token in Page SourceJSON Web Token found in HTML source.
- Base64 Credentials in Page SourceBasic authentication credentials (Base64) found.
- Password Form Uses GET MethodForm with password field uses GET method.
- Session ID Exposed in URLA session identifier (session_id, sid, PHPSESSID, JSESSIONID, or ASP.NET_SessionId) appears as a URL query parameter in the page, carrying a value with the shape of a real session token. A short numeric id, a templated placeholder, or a documentation example such as ?session_id=YOUR_SESSION_ID is not reported.
- OAuth URL Missing State ParameterOAuth authorization URL without state parameter.
- AngularJS 1.x DetectedEnd-of-life AngularJS framework detected.
- Bearer Token Exposed in SourceBearer token found in page source.
- API Key in URL ParameterAPI key found in URL parameter.
- Stripe Secret Key ExposedA Stripe secret key (sk_live_ or sk_test_) was found in the response body. Publishable keys (pk_live_/pk_test_) are deliberately not reported here: Stripe's own integration docs require embedding those in client-side code, so they are public by design.
- SendGrid API Key ExposedSendGrid API key pattern found.
- Mailchimp API Key ExposedMailchimp API key pattern found.
- NPM Token ExposedNPM authentication token found.
- Docker Hub Token ExposedDocker Hub credentials found.
- Framework Error Message ExposedA raw PHP, .NET, Django, MySQL, or PostgreSQL error message was found in the response.
- NoSQL Error Message ExposedNoSQL/MongoDB error found in response.
- SVG with Script ContentSVG containing script elements.
- Script with data: URIScript tag using data: URI source.
- Password Field Type is TextPassword stored in text input instead of password type.
- Form action uses javascript: schemeA <form action="javascript:..."> executes JavaScript on submit and is a classic XSS vector if the action is partially attacker-controlled.
- Sandboxed iframe allows both scripts and same-originCombining sandbox='allow-scripts allow-same-origin' removes most of the sandbox protection and lets the iframe access the parent origin.
- SVG with inline onload handlerAn <svg onload="..."> attribute fires JavaScript when the SVG renders and is equivalent to inline script for XSS purposes.
- WebSocket connection uses unencrypted ws:// protocolThe page opens a WebSocket connection using the unencrypted ws:// protocol instead of the secure wss:// protocol.
- WebSocket connection without origin validationA WebSocket endpoint does not validate the Origin header, allowing connections from any website.
- postMessage receiver does not validate originA message event listener processes messages without checking event.origin, accepting messages from any window.
- DOM XSS sinks with user-controlled inputUser-controlled data is assigned to XSS-prone DOM sinks such as innerHTML, document.write, or eval without sanitization.
- SQL error message in page contentThe page contains an SQL error message that reveals database type, query structure, or table names.
- HTML injection pattern detectedUser-controlled input appears to be reflected in the HTML response without proper encoding, enabling HTML injection.
- DOM XSS Sink or Executable javascript: URIAn inline `<script>` writes a URL-derived value (location, document.URL, document.referrer, or window.name) straight into document.write or innerHTML, or a `javascript:` URI in an href or form target carries a payload that reads cookies or URL data.
- Subdomain Takeover Fingerprint DetectedThe response body matches a known 'unclaimed service' error page (GitHub Pages, Heroku, Fastly, Pantheon, Shopify, Squarespace, or Netlify), which typically means a DNS record still points at a service that no longer has a claim on this hostname.
- Session-Replay Script Near Unmasked Sensitive FieldA session-replay/analytics script (Hotjar, FullStory, LogRocket, Clarity) was detected alongside a sensitive-looking input field (SSN, credit card) that lacks the vendor's data-exclusion attribute.
- Script Loaded From Raw IP AddressA <script> tag loads code from a raw IP address instead of a domain name, which is unusual for legitimate first- or third-party scripts and is a common malvertising/compromise indicator.
- Source Map Publicly Exposes Original Source CodeThe .map file referenced by a //# sourceMappingURL comment was fetched directly and its 'sourcesContent' field is present and non-empty, meaning the original, un-minified source files are embedded in the map and are downloadable by anyone who requests the .map URL. This is a stronger confirmation than the sourcemap-reference check, which only observes the reference comment and cannot say whether the .map file is actually reachable.
Medium44 checks
- Potential Open Redirect ParametersThe page contains URL parameters or JavaScript patterns commonly associated with open redirect vulnerabilities.
- Sensitive File References DetectedThe page references files commonly associated with sensitive configuration or development artifacts.
- Potentially Dangerous Inline JavaScriptThe page contains inline JavaScript with potentially dangerous patterns like eval(), document.write().
- Sensitive Keywords in HTML CommentsHTML comments containing potentially sensitive information detected.
- Insecure Iframe Sources on HTTPS PageIframes loading content over HTTP on an HTTPS page.
- Suspicious Content in Open Graph TagsOpen Graph meta tags contain suspicious content that could indicate injection.
- Window.opener Access DetectedJavaScript accesses window.opener properties, exploitable for reverse tabnabbing.
- Application Error Messages Exposed to UsersDetailed error messages visible in the page HTML.
- Server-Side XML Parsing DetectedServer-side XML parsing library usage found. Ensure external entity processing is disabled.
- POST Forms Without CSRF TokensPOST form(s) found without apparent CSRF token fields. Note: This check skips framework apps (Next.js, Nuxt) that handle CSRF differently.
- Discord Webhook URL ExposedA Discord incoming webhook URL was found in page source.
- API Documentation Publicly AccessibleSwagger/OpenAPI documentation endpoints referenced.
- Deprecated document.domain Usagedocument.domain assignment found.
- AWS S3 Bucket Reference ExposedAn S3 object URL in the page source points at something that looks like it was never meant to be published: a backup, a database dump, a .env or .sql file, a credentials or private-key path. Ordinary asset hosting from S3 (images, downloads, a public config file) is not reported.
- Meta Referrer Tag Leaks URLsMeta referrer tag set to an unsafe value.
- Weak Password Length ConstraintPassword field allows very short passwords.
- Remember-Me Token in URLRemember-me token exposed in URL.
- User Enumeration via EmailError message reveals email existence.
- Potentially Outdated jQueryjQuery version may have known vulnerabilities.
- Prototype.js DetectedOutdated Prototype.js library detected.
- MooTools DetectedOutdated MooTools library detected.
- Slack Webhook URL ExposedSlack webhook URL found in source.
- Google API Key ExposedGoogle API key found in source.
- LDAP Error Message ExposedLDAP error message in response.
- XML Parser Error ExposedXML parser error in response.
- JSONP Endpoint DetectedJSONP callback parameter found.
- Potential DOM ClobberingHTML elements with IDs that could clobber globals.
- Script from blob: URLScript loaded from blob: URL.
- Password Field with Short maxlengthPassword input with very short maxlength.
- Hidden Password Input FieldPassword field with type=hidden.
- Configuration file reference detected in links/assetsThe page contains an href/src/action link to a configuration filename (config.yaml, config.json, .env, docker-compose) that often indicates server-side configuration files.
- srcdoc iframe without sandbox attributeAn <iframe srcdoc="..."> embeds inline HTML directly in the page without a sandbox attribute, giving that inline content full same-origin privileges.
- Missing sandbox attribute on iframeAn iframe element is present without a sandbox attribute, giving the embedded content full access to the same privileges as the parent page.
- Form action points to an insecure or external URLA form action attribute uses plain HTTP, or points to a domain that is neither your own site nor a known form/payment processor, risking submission to an untrusted destination. Forms posting to your own site, or to a processor whose documented embed code requires a cross-origin action (Stripe, PayPal, Mailchimp, HubSpot, Jotform, Salesforce Web-to-Lead, and similar), are not reported.
- Base tag with insecure or dynamic hrefThe HTML base element sets the base URL for all relative links. A user-controlled or HTTP base tag enables base tag hijacking attacks.
- Stack trace exposed in HTTP responseA server error response contains a full stack trace, revealing file paths, line numbers, framework versions, and application structure.
- PHP error/warning in page contentA PHP error, warning, or notice is displayed in the page output, revealing file paths and internal application details.
- ASP.NET error details in page contentASP.NET error details including stack traces or YSOD (Yellow Screen of Death) are shown to end users.
- Sensitive data in Web Storage APIThe page stores potentially sensitive data in localStorage or sessionStorage, which is accessible to all same-origin JavaScript.
- Camera or Microphone API ReferencedThe page references the getUserMedia/mediaDevices camera-or-microphone API. This check only detects the API reference; it does not verify whether the call is gated behind an explicit user action (e.g. a click handler) or fires automatically on load.
- Potential phishing lookalike domain detected in linksOutgoing links or redirects reference domains that closely resemble known trusted brands via typosquatting or homoglyph substitution.
- Service Worker with insecure fetch handlerThe Service Worker intercepts all requests but does not validate origins or enforce HTTPS, potentially caching insecure responses.
- Sensitive source code comment in responseAn HTML comment in the response contains potentially sensitive information such as file paths, credentials, or developer notes.
- WordPress Plugin Version Disclosed via Asset Query StringOne or more WordPress plugin asset URLs include a '?ver=X.Y.Z' query string that discloses the exact installed plugin version.
Low36 checks
- Server version disclosed in response headerA response header carries a value that matches a version-like pattern (e.g. '1.0', '2.3.1').
- Missing Autocomplete Attributes on Sensitive FieldsSensitive input fields without proper autocomplete attributes.
- Forms Targeting New WindowsForms with target="_blank" can be abused for phishing via reverse tabnabbing.
- Meta Refresh Redirect DetectedMeta refresh redirects can be abused for open redirect attacks and phishing.
- Sensitive Endpoints Referenced in Page SourceReferences to potentially sensitive endpoints in the page source.
- Sensitive Information in Meta TagsMeta tags that expose sensitive or unnecessary information.
- Service Worker Registered Without a Narrow ScopeA service worker is registered without an explicit narrow 'scope' option, so it defaults to controlling the entire origin. This is standard, expected behavior for most PWAs -- not itself a vulnerability -- but worth confirming was intentional.
- GraphQL Introspection Query Reference FoundThe page's client-side bundle contains a reference to a GraphQL introspection query string. This is bundled by nearly every GraphQL client library (Apollo, Relay, graphql-request) for fragment matching and codegen, whether or not the server actually has introspection enabled -- this check cannot confirm the server accepts introspection queries, only that the client code mentions them.
- Password Fields Missing Name AttributePassword input fields are missing a name attribute, hindering form submission and password manager functionality.
- Form action uses tel: schemeA <form action="tel:..."> opens the device's phone dialer instead of submitting data anywhere, which is usually a mistake for a form that has input fields.
- Hardcoded IP Addresses in Page SourceMultiple distinct IP addresses found hardcoded in page source (excluding localhost and common non-sensitive IPs).
- document.write() Outside Page Scriptsdocument.write()/document.writeln() found in the response body outside a <script> block, typically in an inline event-handler attribute. Calls inside <script> blocks are reported separately by the client-side scan.
- JavaScript Source Map Reference FoundA //# sourceMappingURL comment pointing to a .map file was found in the page's JavaScript, indicating a source map may be deployed alongside the production bundle.
- Excessive Inline Event HandlersMultiple inline event handler attributes found.
- Firebase Configuration ExposedFirebase configuration object found in page source.
- Debug Endpoints ReferencedDebug or profiler endpoints found in source.
- Admin/Management Path Detected in URLThe scanned URL's path suggests an admin or management panel (e.g. /admin/, /administrator/, /management/). This is a path-shape signal only; the scanner does not check whether the endpoint requires authentication.
- CDN Scripts Without FallbackCDN-hosted scripts without local fallback.
- document.cookie Access Near Session/Auth Datadocument.cookie accesses detected near session/auth-related keywords (token, jwt, auth, session, secret, password).
- Multiple Phone Numbers ExposedMany phone numbers found in page source.
- Twilio Account SID ExposedA Twilio Account SID pattern was found in the page. The Account SID functions like a username, not a secret, and Twilio's own docs describe it as safe to share; it grants no API access without the paired Auth Token.
- JSON Array at Top LevelAPI returns JSON array as top-level response. This check only inspects response shape; it does not check whether the endpoint is session/cookie-authenticated or returns sensitive data, which is what the underlying attack actually requires.
- Iframe with srcdoc AttributeIframe using srcdoc for inline HTML.
- Iframe Sandbox Allows ScriptsSandboxed iframe with allow-scripts.
- Sensitive Data in Readonly FieldSensitive data in readonly input field.
- File Upload Without accept AttributeFile input without accept attribute. The accept attribute is only a client-side UX hint and is trivially bypassed, so its absence does not by itself confirm a server-side validation gap.
- formnovalidate attribute on submit buttonA submit button with formnovalidate bypasses HTML5 input constraints (required, pattern, type=email). This is also the standard, expected attribute for 'save draft'/'skip'/'cancel' buttons in multi-step forms, so its presence alone does not confirm a bypassable validation gap; it's a reminder that server-side validation must catch what the browser doesn't.
- Form action uses mailto: schemeA <form action="mailto:..."> opens the user's mail client, leaks the recipient address, and is unreliable for data submission.
- Geolocation API ReferencedThe page references navigator.geolocation. This check only detects the API reference; it does not verify whether the call is gated behind an explicit user action (e.g. a "Use my location" button) or fires automatically on page load.
- Clipboard API ReferencedThe page references navigator.clipboard or document.execCommand('copy'). This check only detects the API reference; it does not verify whether the call is gated behind user interaction. The single most common use of this API is a benign "copy to clipboard" button.
- Internal API version exposed in responseThe API response includes an internal version string or build number that reveals implementation details.
- Server information disclosed in responseThe HTTP response reveals server software name and/or version in the Server, X-Powered-By, or similar headers.
- Paste disabled on password fieldThe password input field has JavaScript that prevents pasting, making password manager use difficult.
- Hard-coded IP addresses in sourcePrivate or public IP addresses are hard-coded in the client-side source, potentially revealing internal infrastructure.
- Ad-Tech Tracking Pixel on Login PageAn ad-tech tracking pixel (Meta, TikTok, Snap, or LinkedIn) was detected on a page that also contains a login form, increasing the third-party attack surface on a credential-entry page.
- Copy Event Listener Rewrites Clipboard ContentA 'copy' event listener was found that rewrites the clipboard contents via clipboardData.setData(). This is also the standard, MDN-documented technique for legitimate copy-customization features (e.g. a 'copy code snippet' button), so this alone does not confirm clipboard-hijacking.
Info6 checks
- robots.txt Present - Review ManuallyThe response body looks like a robots.txt file. This check only confirms the file's format (User-agent/Disallow directives); it does not inspect which paths are listed.
- CMS / Technology FingerprintingThe site exposes CMS or technology stack details that aid attacker reconnaissance.
- Viewport Prevents User ZoomThe viewport meta tag disables user scaling (user-scalable=no or maximum-scale=1), which is an accessibility issue.
- Excessive Third-Party Domain ConnectionsThe page connects to a large number of distinct third-party domains (10+), increasing attack surface.
- Form Disables AutocompleteForm has autocomplete=off.
- WordPress login page publicly accessibleThe WordPress admin login page (/wp-login.php or /wp-admin/) is publicly accessible, exposing it to brute-force attacks.
About the Content checks
- What does the Content category check?
- Scan page content for XSS sinks, reflected parameters, open redirects, and mixed content: the injection surface that lives in the HTML and JavaScript a page actually ships. XSS sinks, reflected parameters, open redirects, mixed content.
- How many content checks are there?
- VulnRadar runs 144 checks in this category, ranging across critical, high, medium, low, info severity.
- Do I need to install anything to run the content checks?
- No. Paste a URL in the browser or call the REST API, and the scan itself runs from our servers against that URL. There is no agent and no appliance to deploy alongside your application. A browser extension exists if you want to scan the page you are looking at, but nothing has to be installed to use this.
Run the content checks on your site
VulnRadar runs all 144 of these against a URL in seconds, with the evidence and fix for every finding. No agent to install, just paste a URL.