# API Keys & Credits Source: https://docs.jsmon.sh/api-keys-and-credits Generate API keys, track credit usage, and integrate Jsmon programmatically The **API** tab in Settings lets you generate API keys for programmatic access and monitor your credit consumption. ## API Keys API keys allow you to interact with Jsmon programmatically — trigger scans, retrieve results, and integrate with your existing security toolchain. ### Generating an API Key #### Navigate to Settings → API Open Settings and click the **API** tab. #### Create New Key Click **Generate API Key**. A new key is created and displayed once. #### Copy and Store Securely Copy the key immediately — it will not be shown again. Store it in a secure location like a password manager or secrets vault. Treat your API key like a password. Never commit it to version control or share it publicly. If compromised, revoke it immediately and generate a new one. ### Managing API Keys | Action | Description | | -------------- | ------------------------------------------------------- | | **Copy** | Copy the key value to your clipboard | | **Revoke** | Permanently deactivate the key | | **Regenerate** | Create a new key (the old one is automatically revoked) | ## Credit Tracking | Metric | Description | | --------------------- | ----------------------------------------------------------- | | **Total Credits** | Your plan's monthly allocation plus any add-on credits | | **Used Credits** | Credits consumed so far this billing cycle | | **Remaining Credits** | Credits still available | | **Reset Date** | When your plan credits refresh (add-on credits don't reset) | ## Quick API Example ```bash theme={null} curl -X POST https://api.jsmon.sh/api/v1/scan \ -H "Authorization: Bearer YOUR_API_KEY" \ -H "Content-Type: application/json" \ -d '{"type": "domain", "target": "example.com", "workspace": "WORKSPACE_ID"}' ``` Full API documentation with all available endpoints and code examples is available in the API Reference section. # Bulk Scan Source: https://docs.jsmon.sh/bulk-scan Scan multiple targets simultaneously Bulk Scan lets you submit multiple targets at once instead of scanning them one at a time. This is ideal for large-scale reconnaissance across many domains, subdomains, or IP ranges. ## How to Run a Bulk Scan 1. Navigate to the **Scans** page in your workspace 2. Click the **Bulk Scan** button (next to Domain Scan) 3. The input area expands to show a multi-line text field and a file upload zone ### Enter Targets Manually Type or paste your targets in the text area, one per line. Supported target formats include: * **Domains** — `example.com` * **Subdomains** — `sub.example.com` * **IP Addresses** — `203.43.10.452` * **CIDR Ranges** — `10.43.10.45/16` ### Upload a Target List Alternatively, click the **Paste or upload files** area to upload a text file containing your target list (one target per line). 4. Optionally configure scan options by clicking **Options (Depth, Headers, Extensions)** 5. Click the **Start Scan** button to begin scanning all targets ## Best Practices * Keep your target lists organized and free of duplicates * Be mindful of your scan credit balance when running large bulk scans * Use the Options panel to set appropriate crawl depth for your use case — deeper crawls consume more credits * Consider enabling monitoring on important targets after the initial bulk scan Bulk scans consume credits for each target scanned. Verify your credit balance before submitting large target lists. # Burpsuite Extension Source: https://docs.jsmon.sh/burp-suite-extension A powerful Burp Suite extension that automatically scans files using the Jsmon API to discover secrets, API endpoints, domains, and other intelligence A powerful Burp Suite extension that automatically scans scannable files using the Jsmon API. Discover secrets, API endpoints, domains, and other intelligence from web files as you browse. ## Features * **Easy API Key Configuration** — Enter your Jsmon API key directly in the extension * **Workspace Management** — Fetch existing workspaces or create new ones * **Domain Scoping** — Limit scanning to specific domains (includes subdomains) * **Automatic Scanning** — Automatically scan scannable files as you browse * **Intelligence Dashboard** — View secrets, JS URLs, API paths, domains, IPs, emails, S3 buckets, and more * **Copy to Clipboard** — One-click copy for all intelligence data * **Real-time Updates** — See scan results and counts update in real-time * **Dark/Light Theme Support** — Automatically adapts to Burp Suite's theme ## Requirements | Requirement | Details | | ----------------- | -------------------------------------------------------------------------- | | **Burp Suite** | Professional or Community Edition (2024.1 or later) | | **Java** | Java 11 or higher | | **Jsmon Account** | API key required — generate from [Settings](https://app.jsmon.sh/settings) | ## Installation Download the latest `jsmon-burp-extension-1.1.0.jar` file from the [GitHub repository](https://github.com/jsmonhq/jsmon-burpsuite-extension). Go to the **Extensions** tab and click the **Add** button. Select **Extension type**: Java, then click **Select file** and choose the downloaded JAR file. Verify the extension loads without errors in the **Output** tab. You should see a new **JSMon** tab in Burp Suite. ## Quick Start Guide ### Step 1: Configure API Key 1. Open the **JSMon** tab in Burp Suite. 2. Enter your Jsmon API key in the "API Key" field. 3. Click **Fetch Workspaces** to retrieve your workspaces. 4. Your user profile (name, email, JSScan credits) will be displayed automatically. ### Step 2: Select or Create Workspace * **Select Existing Workspace**: Choose a workspace from the dropdown. * **Create New Workspace**: Enter a name and click **Create**. ### Step 3: Configure Domain Scoping (Optional) * Enter domain(s) in the "Domain Scoping" field (one per line or comma-separated). * Leave empty to scan all files regardless of domain. * Subdomains are automatically included (e.g., `example.com` includes `sub.example.com`). ### Step 4: Enable Automatic Scanning Check **Enable Automatic Scanning** to automatically scan scannable files as you browse. When enabled, the extension will: * Scan all existing scannable files in Burp's history * Automatically process new scannable files as you browse * Respect your domain scoping settings ### Step 5: View Intelligence Data Click on the **JS-Intelligence Data** tab to view: * **Secrets** — API keys, tokens, and other secrets found * **JS URLs** — All JavaScript files discovered * **API Paths** — API endpoints extracted from files * **URLs** — All URLs found in files * **Domains** — Domains discovered * **IP Addresses** — IP addresses found * **Emails** — Email addresses discovered * **S3 Buckets** — S3 bucket names found * **Invalid Node Modules** — NPM confusion packages detected ## Usage ### Automatic Scanning When automatic scanning is enabled: * The extension monitors all HTTP responses in Burp Suite * Scannable files are automatically detected (by file extension or `Content-Type` header) * Files are sent to Jsmon API with all relevant headers (User-Agent, Cookie, Authorization, etc.) * Each URL is processed only once to avoid duplicates * Results appear in real-time in the intelligence tabs ### Manual Scanning 1. Click **Start Manual Scan** to scan all scannable files from Burp's HTTP history. 2. Progress is shown in the status log. 3. Results are automatically displayed in the intelligence tabs. ### Viewing Intelligence Data * **Secrets Tab**: View all secrets found (API keys, tokens, etc.) * **JS Intelligence Tabs**: Browse through different types of intelligence data * **Counts**: Each tab shows the total count in parentheses (e.g., "Emails (188)") * **Pagination**: Use **Prev** and **Next** buttons to navigate through pages * **Copy All**: Click **Copy All** button to copy all data from a tab to clipboard ### Copying Data * **Copy Selected Cells**: Select cells in any table and press `Ctrl+C` (or `Cmd+C` on Mac) * **Copy All Data**: Click the **Copy All** button at the bottom of each intelligence tab — this copies all values from the first column, one item per line ## Configuration Options | Option | Description | | ---------------------- | ------------------------------------------------------------------ | | **API Key** | Your Jsmon API key (required) | | **Workspace** | The workspace where scan results will be stored (required) | | **Scoped Domain** | Domain(s) to limit scanning scope. Leave empty to scan all domains | | **Automatic Scanning** | Enable/disable automatic scanning of scannable files | ## Understanding the Intelligence Data ### Secrets API keys, tokens, passwords, and other sensitive information found in files. ### JS URLs All file URLs that have been scanned. Useful for identifying all scannable files in scope. ### API Paths API endpoints and paths extracted from files. Great for discovering hidden endpoints. ### URLs All URLs found in files, including internal and external links. ### Domains All domains discovered in files. Helps identify all domains used by the application. ### IP Addresses IP addresses found in files, including internal and external IPs. ### Emails Email addresses discovered in files. Useful for identifying contacts and user emails. ### S3 Buckets Amazon S3 bucket names found in files. Can reveal misconfigured or exposed buckets. ### Invalid Node Modules NPM confusion packages detected — packages with typosquatting or suspicious names. ## Tips & Best Practices **Start with Domain Scoping** — Limit your scans to your target domain to avoid scanning unrelated files. * **Monitor JSScan Credits**: Check your remaining credits in the User section. * **Use Manual Scan First**: Run a manual scan to see what data is available before enabling automatic scanning. * **Export Data Regularly**: Use the Copy All buttons to export data for further analysis. * **Check Secrets First**: Always review the Secrets tab first as it contains the most critical findings. ## Troubleshooting * Ensure you are using Burp Suite 2024.1 or later * Check that Java 11+ is installed * Verify the JAR file is not corrupted * Check the **Output** tab in Burp Suite for error messages * Verify your API key is correct * Check your internet connection * Look for error messages in the status log * Ensure **Automatic Scanning** is enabled * Check that the domain matches your scoped domain (if set) * Verify the workspace is selected * Check the status log for any error messages * Counts are fetched automatically when you select a workspace * Try selecting the workspace again * Click on the intelligence tabs to refresh data * Check if there is actual data in your workspace ## Version and Links | Field | Value | | --------------- | ---------------------------------------------------------------------------------------------------- | | Current Version | 1.1.0 | | GitHub | [github.com/jsmonhq/jsmon-burpsuite-extension](https://github.com/jsmonhq/jsmon-burpsuite-extension) | | Support | [support@jsmon.sh](mailto:support@jsmon.sh) | # Chrome Extension Source: https://docs.jsmon.sh/chrome-extension Passively scan your browser traffic for security vulnerabilities with the Jsmon Chrome Extension The Jsmon Chrome Extension performs security scans on your browser's network traffic in the background. It automatically monitors web traffic and analyzes JavaScript files and API responses for security vulnerabilities — no manual uploads or proxies required. Install from Chrome Web Store ## How It Works 1. Install the extension from the Chrome Web Store. 2. Open the extension and enter your **Jsmon API key** to authenticate with your account. 3. Browse normally — the extension passively captures traffic in the background. 4. Matched file types are forwarded to Jsmon's scanning engine for analysis. 5. Findings appear in your Jsmon dashboard showing secrets, APIs, risks, and asset inventory. You need a Jsmon API key to use this extension. Generate one from **Settings → API** in the [Jsmon web app](https://app.jsmon.sh/settings). ## What It Detects * **Exposed Secrets** — API keys, tokens, and leaked credentials in JavaScript or configuration files * **Shadow APIs** — Undocumented or forgotten endpoints in frontend code * **Supply Chain Risks** — Vulnerable or suspicious NPM packages loaded at runtime * **Sensitive Data Exposure** — PII, internal paths, environment variables * **Misconfigured Assets** — Insecure headers, open redirects, debug artifacts The extension supports **20+ file extensions** for analysis, including JavaScript, TypeScript, JSON, HTML, and more. ## Who It's For * Security engineers conducting reconnaissance or penetration testing * AppSec and EASM teams monitoring external attack surfaces * Bug bounty hunters accelerating JavaScript reconnaissance * CISOs and compliance teams requiring continuous visibility ## Permissions The extension requires access to: * Authentication information * Web history * Website content Data is not sold to third parties, not used for unrelated purposes, and not used for creditworthiness determinations. ## Details | Field | Value | | --------- | ------------------------------------------- | | Version | 2.1 | | Size | 2.06 MiB | | Developer | Jsmon (jsmon.sh) | | Category | Developer Tools | | Contact | [support@jsmon.sh](mailto:support@jsmon.sh) | # CLI Tool Source: https://docs.jsmon.sh/cli-tool The official command-line tool for Jsmon. Scan URLs, domains, and source code, upload files, and explore reconnaissance and vulnerability data from your terminal. The official command-line tool for [Jsmon](https://jsmon.sh). Scan URLs, domains, and source code, upload files, and explore reconnaissance and vulnerability data from your terminal. ## Quick Start 1. **Install** the CLI (see [Installation](#installation)). 2. **Set your API key** (flag, file, or env — see [Configuration](#configuration)). 3. **Create or pick a workspace**, then start scanning. ```bash theme={null} # Create a workspace jsmon -cw "My Project" -key YOUR_API_KEY # Scan a URL (use the workspace ID from the previous command) jsmon -u "https://example.com/app.js" -wksp YOUR_WORKSPACE_ID # List reconnaissance data (e.g. emails) jsmon -recon "field=emails page=1" -wksp YOUR_WORKSPACE_ID ``` ## Installation ### Option 1: Install from Go (recommended) ```bash theme={null} go install github.com/jsmonhq/jsmon-cli/v2/cmd/jsmon@latest ``` Ensure your Go `bin` directory is in your `PATH` (e.g. `$HOME/go/bin`). The installed command is `jsmon`. ### Option 2: Build from source ```bash theme={null} git clone https://github.com/jsmonhq/jsmon-cli.git cd jsmon-cli go build -o jsmon ./cmd/jsmon ``` This creates a local `jsmon` binary from source. ## Configuration ### API Key Get your API key from [Jsmon Settings](https://app.jsmon.sh/settings). The CLI looks for it in this order: | Priority | Source | | -------- | ---------------------------- | | 1 | `-key YOUR_API_KEY` | | 2 | File: `~/.jsmon/credentials` | | 3 | Environment: `JSMON_API_KEY` | **Credentials file:** Create `~/.jsmon/credentials` and put your API key on the first line (no label). Lines starting with `#` are ignored. ### Workspace ID For scanning and data commands you need a **workspace ID**: * Pass it with `-wksp YOUR_WORKSPACE_ID`, or * Set `JSMON_WORKSPACE_ID` in your environment. The workspace ID is **not** read from the credentials file; it must be provided per command or via env. ### Optional Flags * `-H "Header-Name: value"` — Add custom HTTP headers for scan requests (can be used multiple times). * `-silent` — Hide the Jsmon logo when running commands. * `-depth 1..4` / `-scan-depth 1..4` — Control domain scan depth. * `-wafbypass` / `-waf-bypass` — Enable WAF bypass for URL, domain, and file scans. * `-keywords "api,admin"` / `-scan-keywords "api,admin"` — Add domain scan keywords. * `-extensions "js,json"` / `-scan-extensions "js,json"` — Limit domain scans to supported extensions. Scan commands submit work to Jsmon's asynchronous pipeline. The CLI prints the queued `runId` and `version`; use those values with read commands when you want run-scoped or version-specific results. ## Commands Overview ```text theme={null} Usage: jsmon [OPTIONS] Input: -u Input URL to scan -d Input domain to scan -cs | -code-scan Input source code file to scan -f Upload a URL list file for server-side file scan -cw | --create-workspace Create a new workspace Configuration: -key API key -wksp Workspace ID to scan the target -runId Existing run ID for rescan or run-scoped counts -depth <1..4> | -scan-depth <1..4> Optional scan depth for domain scans -wafbypass | -waf-bypass Enable WAF bypass -keywords | -scan-keywords Optional domain scan keywords -extensions | -scan-extensions Optional domain scan extensions -H Custom HTTP headers -silent Silent the logo -up, --update Check for updates -duc, --disable-update-check Disable automatic update check on startup Scans: -count Show counts of recon data and secrets --urls "page= limit=" Fetch all scanned URLs --domains "page= limit=" Fetch all scanned domains --files "page= limit=" Fetch all scanned files Data: -workspaces Fetch all workspaces -issues "page= limit= ..." Fetch dashboard vulnerabilities -secrets "page= limit= ..." Fetch all secrets for a workspace -recon "field= page= limit=" Fetch reconnaissance data Reverse Search: -rsearch "=" Search the source of a result Filter: -filters "= page=" Match keywords in recon results ``` ## Scanning ### Upload a single URL ```bash theme={null} jsmon -u "https://example.com/script.js" -wksp YOUR_WORKSPACE_ID ``` ### Scan a domain ```bash theme={null} jsmon -d "example.com" -wksp YOUR_WORKSPACE_ID jsmon -d "example.com" -depth 3 -wksp YOUR_WORKSPACE_ID jsmon -d "example.com" -depth 3 -keywords "api,admin" -extensions "js,json" -wksp YOUR_WORKSPACE_ID jsmon -d "example.com" -wafbypass -wksp YOUR_WORKSPACE_ID ``` `-depth`, `-keywords`, and `-extensions` are domain-scan only. Supported extension values are `html`, `php`, `txt`, `js`, `xml`, `json`, `map`, `xhtml`, and `aspx`. ### Upload a source code file ```bash theme={null} jsmon -cs app.js -wksp YOUR_WORKSPACE_ID ``` ### Upload multiple URLs from a file Put one URL per line in a file, then submit the file to Jsmon's server-side file scan: ```bash theme={null} jsmon -f urls.txt -wksp YOUR_WORKSPACE_ID jsmon -f urls.txt -wafbypass -wksp YOUR_WORKSPACE_ID ``` The response includes `runId` and `version`. Re-submit the file if a queued file scan fails before processing. ## Viewing Data ### Workspaces ```bash theme={null} jsmon -workspaces -key YOUR_API_KEY ``` ### Scanned URLs, domains, and files ```bash theme={null} jsmon --urls "page=1 limit=50" -wksp YOUR_WORKSPACE_ID jsmon --domains "page=1 limit=50" -wksp YOUR_WORKSPACE_ID jsmon --files "page=1 limit=50" -wksp YOUR_WORKSPACE_ID ``` Default is `page=1` and `limit=100` if omitted. (Max limit: 5000 per page) ### Secrets ```bash theme={null} jsmon -secrets "page=1 limit=100" -wksp YOUR_WORKSPACE_ID ``` ### Dashboard vulnerabilities ```bash theme={null} jsmon -issues "page=1 limit=20" -wksp YOUR_WORKSPACE_ID jsmon -issues "page=1 limit=20 severity=critical,high dateFrom=2026-04-01 dateTo=2026-04-14" -wksp YOUR_WORKSPACE_ID ``` The `-issues` command mirrors the dashboard vulnerability table and returns `data`, `severityCount`, and `pagination`. ### Count summary ```bash theme={null} jsmon -count -wksp YOUR_WORKSPACE_ID ``` Optional: add `-runId RUN_ID` for a specific run. ## Reconnaissance & Filters ### Fetch reconnaissance data Get extracted intelligence for a **field** and optional pagination: ```bash theme={null} jsmon -recon "field=emails page=1 limit=50" -wksp YOUR_WORKSPACE_ID ``` **Common fields:** `apiPaths`, `urls`/`jsurls` (scanned URLs), `extractedUrls`, `extractedDomains`, `expiredDomains`, `ip`, `emails`, `s3Buckets`, `gqlQueries`, `gqlMutations`, `gqlFragments`, `param`, `allAwsAssets`, `npmPackages`, `socialUrls`, `portUrls`, `extensionUrls`, and others (see `jsmon -h`). Add `runId=` to scope results to one scan. Add `version=` with `runId` to inspect a specific monitoring/rescan version. ### Filter by keyword Search within a field (e.g. only URLs containing "github"): ```bash theme={null} jsmon -filters "urls=github.com page=1" -wksp YOUR_WORKSPACE_ID jsmon -filters "param=github page=1" -wksp YOUR_WORKSPACE_ID ``` Format: `"fieldname=keyword page=N limit=N"`. Defaults: `page=1`, `limit=100`. ## Reverse Search Find where a value came from (e.g. which script exposes an API path): ```bash theme={null} jsmon -rsearch "apipaths=@azure/msal-browser" -wksp YOUR_WORKSPACE_ID jsmon -rsearch "extractedDomains=blogs.jsmon.sh" -wksp YOUR_WORKSPACE_ID ``` Format: `"fieldname=value"`. Use **extractedDomains** (not `domains`) for domain reverse search. ## Advanced Scan Options ```bash theme={null} # URL scan with WAF bypass jsmon -u "https://example.com/app.js" -wafbypass -wksp YOUR_WORKSPACE_ID # Domain scan with depth, keywords, extensions, and WAF bypass jsmon -d "example.com" -depth 3 -keywords "api,admin" -extensions "js,json" -wafbypass -wksp YOUR_WORKSPACE_ID # File scan with WAF bypass jsmon -f urls.txt -wafbypass -wksp YOUR_WORKSPACE_ID ``` Allowed extensions: `html`, `php`, `txt`, `js`, `xml`, `json`, `map`, `xhtml`, `aspx`. ## Updates * **Automatic:** On startup the CLI checks for a newer release and prints a message if one exists (no auto-download). * **Manual check:** `jsmon -up` or `jsmon --update` to check and see the install command. * **Disable startup check:** `jsmon -duc` or `jsmon --disable-update-check`. To upgrade after a new release: ```bash theme={null} go install github.com/jsmonhq/jsmon-cli/v2/cmd/jsmon@latest ``` ## Field Names Reference ### For `-recon` and `-rsearch`: `apiPaths`, `urls`/`jsurls` (scanned URLs), `extractedUrls`, `extractedDomains`, `ip`, `emails`, `s3Buckets`, `s3takeovers`, `gqlQueries`, `gqlMutations`, `gqlMutaions`, `gqlFragments`, `param` (extracted parameter), `npmPackages`, `npmConfusion`, `guids`, `localhost`, `expiredDomains`, `allAwsAssets`, `socialUrls`, `portUrls`, `extensionUrls` ### For `-filters`: `jsurls`, `apiPaths`, `urls`, `emails`, `gqlQueries`, `gqlMutations`, `gqlMutaions`, `sqlFragments`, `param` (extracted parameter) ## Examples ```bash theme={null} # Create workspace jsmon -cw "My Project" -key YOUR_API_KEY # Scan targets jsmon -u "https://example.com/script.js" -wksp YOUR_WORKSPACE_ID jsmon -u "https://example.com/script.js" -wafbypass -wksp YOUR_WORKSPACE_ID jsmon -d "example.com" -wksp YOUR_WORKSPACE_ID jsmon -d "example.com" -depth 2 -wksp YOUR_WORKSPACE_ID jsmon -d "example.com" -depth 3 -keywords "api,admin" -extensions "js,json" -wafbypass -wksp YOUR_WORKSPACE_ID jsmon -cs app.js -wksp YOUR_WORKSPACE_ID jsmon -f urls.txt -wksp YOUR_WORKSPACE_ID # Use credentials file (no -key needed) jsmon -u "https://example.com/script.js" -wksp YOUR_WORKSPACE_ID # Reconnaissance jsmon -recon "field=emails page=1" -wksp YOUR_WORKSPACE_ID jsmon -recon "field=allAwsAssets page=1" -wksp YOUR_WORKSPACE_ID jsmon -issues "page=1 limit=20 severity=critical,high" -wksp YOUR_WORKSPACE_ID # Filter and reverse search jsmon -filters "urls=api page=1" -wksp YOUR_WORKSPACE_ID jsmon -rsearch "apipaths=/auth/login" -wksp YOUR_WORKSPACE_ID ``` ## Links * **GitHub:** [github.com/jsmonhq/jsmon-cli](https://github.com/jsmonhq/jsmon-cli) * **Jsmon:** [jsmon.sh](https://jsmon.sh) # Code Scan Source: https://docs.jsmon.sh/code-scan Analyze source code for secrets and security issues Code Scan allows you to analyze source code directly for leaked secrets, credentials, and other sensitive data. Instead of scanning a live URL, you provide code content for analysis. ## How to Run a Code Scan 1. Navigate to the **Scans** page in your workspace 2. Click the **+** button next to Domain Scan to open the scan type selector 3. Select **Code Scan** from the dropdown 4. Paste your code or upload code files for analysis 5. Click the **Start Scan** button ## When to Use Code Scan Code Scan is useful for: * Checking source code before committing to a repository * Analyzing JavaScript bundles for hardcoded secrets * Scanning configuration files for exposed credentials * Auditing code snippets from any source # Creating an Account Source: https://docs.jsmon.sh/creating-an-account Sign up for Jsmon and set up your profile Getting started with Jsmon takes less than a minute. Follow these steps to create your free account. Go to [app.jsmon.sh](https://app.jsmon.sh) and click **Signup for Free**. You can also reach the signup page from [jsmon.sh](https://jsmon.sh) by clicking the **Signup for Free** button in the top navigation. Sign up using your email address or use a social login provider. No credit card is required — the free Starter plan is activated automatically. Once logged in, navigate to **Settings → My Details** to update your display name, email address, and upload a profile photo. After signing in, you'll land on the Workspaces page. Click the **+** button to create a new workspace. Give it a name that describes the project or target program you'll be working on. Once your account is set up, you're ready to run your first scan. # Creating & Managing Workspaces Source: https://docs.jsmon.sh/creating-and-managing-workspaces Create, organize, and manage your Jsmon workspaces Workspaces are the top-level organizational unit in Jsmon. Each workspace contains its own set of scans, reconnaissance data, secrets, and monitoring configurations. ## The Workspaces Page When you log into Jsmon, you land on the Workspaces page. This page displays all your workspaces as cards, each showing: * **Workspace name** and creation date * **URLs** — Total number of URLs discovered * **Domains** — Number of unique domains found * **Issues** — Total issues/vulnerabilities detected * **Invited** badge — Appears on workspaces shared with you by others A **Search workspaces** bar at the top lets you quickly find workspaces by name. ## Creating a New Workspace To create a new workspace: 1. Click the **+** button (or **Create Workspace** button) on the Workspaces page 2. Enter a name for your workspace 3. Click **Create** Give your workspace a descriptive name that reflects its purpose — for example, the name of the target program, client, or project. ## Opening a Workspace Click the **Open** button on any workspace card to enter it. This takes you to the Scans page for that workspace, where you can start scanning targets. ## Workspace ID Each workspace has a unique identifier (Workspace ID) displayed at the top of every page within the workspace. You can copy this ID using the copy icon next to it. The Workspace ID is needed when using the Jsmon API. ## Switching Between Workspaces To switch to a different workspace, click **Switch Workspaces** in the left sidebar. This takes you back to the Workspaces page where you can open a different workspace. ## Workspace Menu Click the three-dot menu (**⋮**) on any workspace card to access additional options for managing that workspace, such as renaming or deleting it. # Dashboard Source: https://docs.jsmon.sh/dashboard View your vulnerability overview and scan summary at a glance The Dashboard is the first screen you see when you open a workspace. It provides a high-level overview of all vulnerabilities and issues discovered across your scans. ## Severity Overview Cards At the top of the Dashboard, four severity cards display the count of issues found at each level: | Severity | Description | | ------------ | ----------------------------------------------------------------------------------- | | **Critical** | Severe vulnerabilities that pose an immediate risk and should be addressed urgently | | **High** | Significant security issues that could lead to data exposure or unauthorized access | | **Medium** | Moderate-risk findings that should be reviewed and remediated | | **Low** | Minor issues or informational findings with limited direct impact | Clicking on any severity card filters the vulnerability table below to show only issues of that severity level. ## Vulnerability Table Below the severity cards, a detailed table lists all discovered vulnerabilities with the following columns: * **Name** — The type or title of the vulnerability found * **Severity** — The risk level (Critical, High, Medium, or Low) * **Value** — The specific value or payload associated with the finding * **URL** — The URL where the vulnerability was discovered * **Found On** — The date the issue was first detected You can search, sort, and filter the table to focus on specific findings. The Dashboard aggregates results from all scans within the workspace, giving you a single view of your security posture. # Domain Scan Source: https://docs.jsmon.sh/domain-scan Scan an entire domain to discover assets and vulnerabilities Domain Scan is the primary scan type in Jsmon. It takes a domain name as input and automatically crawls the entire domain to discover URLs, JavaScript files, API endpoints, and other web assets. It then analyzes everything it finds for vulnerabilities, leaked secrets, and reconnaissance data. ## How to Run a Domain Scan 1. Navigate to the **Scans** page in your workspace 2. Ensure **Domain Scan** is selected (it's the default scan type) 3. Enter a domain in the input field (e.g., `example.com`) 4. Optionally configure scan options by clicking **Options (Depth, Headers, Extensions)** 5. Click the **Start Scan** button ## What Gets Scanned A domain scan discovers and analyzes: * All accessible web pages and URLs on the domain * JavaScript files and their contents * API endpoints and routes * HTTP response headers * Form parameters and query strings * External resources and dependencies ## Scan Results After a scan completes, click on it in the scan list to view results in the detail panel. Results are organized into three tabs: ### Overview The Overview tab provides a high-level summary with cards showing: * **API Endpoints** — Number of API endpoints discovered * **URLs Scanned** — Total URLs analyzed * **Issues** — Number of vulnerabilities found * **PII Data** — Personally identifiable information detected Below the summary cards, a list of discovered endpoints is displayed. ### Secrets The Secrets tab shows any leaked API keys, tokens, credentials, or other sensitive data found during the scan. ### Reconnaissance The Reconnaissance tab displays all discovered assets organized into categories (see the Reconnaissance section for details on each category). ## Additional Actions From the scan detail panel, you can: * **Rescan** — Run the scan again to check for changes * **Download** — Export the scan results * **View All Versions** — Access previous scan results using the version dropdown # Extensions Source: https://docs.jsmon.sh/extensions Download and install Jsmon browser extensions, Burp Suite plugin, and CLI tool The **Extensions** tab in Settings provides download links and setup instructions for all Jsmon tools beyond the web interface. ## Available Extensions | Extension | Platform | Description | | ------------------------ | ------------------------ | --------------------------------------------------------- | | **Chrome Extension** | Google Chrome | Send URLs and domains to Jsmon directly from your browser | | **Firefox Extension** | Mozilla Firefox | Same functionality for Firefox users | | **Burp Suite Extension** | Burp Suite Pro/Community | Integrate Jsmon into your Burp Suite workflow | | **CLI Tool** | macOS, Linux, Windows | Run scans from your terminal or CI/CD pipelines | ## Browser Extensions The Jsmon browser extension adds a right-click context menu to quickly send any URL or domain to Jsmon for scanning. ### Installation #### Download the Extension Go to **Settings → Extensions** and click the download link for your browser. #### Install in Your Browser Follow your browser's standard extension installation process. #### Authenticate Click the Jsmon extension icon and log in with your Jsmon credentials. #### Start Scanning Right-click any page or link and select **Send to Jsmon** to initiate a scan. ## Burp Suite Extension The Burp Suite extension lets you send discovered URLs from Burp's sitemap or proxy history directly to Jsmon. Download the `.jar` file from **Settings → Extensions**, then in Burp Suite go to **Extender → Extensions → Add** and select the downloaded file. Configure your Jsmon API key in the extension settings. The Burp Suite extension requires an active Jsmon plan with API access (Recon or Recon Pro). ## CLI Tool The Jsmon CLI lets you run scans from the command line — perfect for scripting, automation, and CI/CD integration. ### Basic Usage ```bash theme={null} # Authenticate jsmon auth login --api-key YOUR_API_KEY # Run a domain scan jsmon scan domain example.com --workspace my-workspace # Run a bulk scan from a file jsmon scan bulk -f targets.txt --workspace my-workspace # Check scan status jsmon scan status SCAN_ID ``` The CLI tool respects your plan's credit limits. Each scan triggered via CLI consumes credits just like web or API scans. # Firefox Extension Source: https://docs.jsmon.sh/firefox-extension Passively scan your browser traffic for security vulnerabilities with the Jsmon Firefox Extension The Jsmon Firefox Extension — also known as the Jsmon Security Analyzer — automatically captures and analyzes web traffic directly from your browser. It sends matched files to Jsmon's External Attack Surface Management (EASM) engine for analysis, without requiring manual uploads or proxies. Install from Firefox Add-ons ## How It Works 1. Install the extension from Firefox Add-ons. 2. Open the extension and enter your **Jsmon API key** to authenticate with your account. 3. Browse normally — the extension passively captures traffic in the background. 4. Matched file types are forwarded to Jsmon's scanning engine for analysis. 5. Findings appear in your Jsmon dashboard showing secrets, APIs, risks, and asset inventory. You need a Jsmon API key to use this extension. Generate one from **Settings → API** in the [Jsmon web app](https://app.jsmon.sh/settings). ## What It Detects * **Exposed Secrets** — API keys, tokens, and credentials in JavaScript or configuration files * **Shadow APIs** — Undocumented endpoints in frontend code * **Supply Chain Risks** — Vulnerable or suspicious NPM packages * **Sensitive Data Exposure** — PII, internal paths, environment variables * **Misconfigured Assets** — Insecure headers, open redirects, debug artifacts ## Supported File Types The extension analyzes **20+ file formats** including: JavaScript, JSX, TypeScript, HTML, PHP, ASPX, YAML, JSON, XML, environment files, and others. ## Who It's For * Security engineers conducting reconnaissance or penetration testing * AppSec and EASM teams monitoring external attack surfaces * Bug bounty hunters accelerating JavaScript reconnaissance * CISOs and compliance teams requiring continuous visibility ## Permissions The extension requires: * Access to browser tabs * Access to your data for all websites ## Details | Field | Value | | --------- | ------------------------------------------- | | Version | 2.0 | | Size | 4.13 MB | | License | MIT | | Developer | Jsmon (jsmon.sh) | | Contact | [support@jsmon.sh](mailto:support@jsmon.sh) | # Community Edition Source: https://docs.jsmon.sh/index AI-Powered External Attack Surface Management Platform Jsmon is an AI-powered External Attack Surface Management (EASM) platform designed for bug bounty hunters, penetration testers, security researchers, and enterprise security teams. It automates the discovery, scanning, and monitoring of web assets — identifying vulnerabilities, leaked secrets, exposed APIs, and reconnaissance data across your attack surface. Whether you're running a solo bug bounty program or managing enterprise-wide security operations, Jsmon gives you the tools to scan domains, discover hidden assets, detect leaked credentials, and monitor for changes — all from a single platform. ## Quick Navigation Create your account, run your first scan, and understand how credits work. Domain scans, URL scans, code scans, bulk scanning, and advanced options. Explore 20+ categories of discovered assets including APIs, domains, secrets, and more. Find leaked API keys, tokens, and credentials across your scanned targets. Set up continuous monitoring with alerts via Email, Discord, and Slack. Browser extensions, Burp Suite, CLI tool, and API access. ## Key Features | Feature | Description | | -------------------------- | ----------------------------------------------------------------------- | | **Domain Scanning** | Discover subdomains, DNS records, technologies, and more | | **URL Scanning** | Deep analysis of specific URLs including headers, scripts, and APIs | | **Code Scanning** | Analyze JavaScript files for API endpoints, secrets, and sensitive data | | **Reconnaissance** | 20+ categories of asset intelligence from a single scan | | **Keys & Secrets** | Automatic detection of leaked API keys, tokens, and credentials | | **Monitoring** | Scheduled scans with change detection and multi-channel alerts | | **Bulk Scanning** | Scan hundreds of targets at once via text input or file upload | | **API Access** | Full REST API for programmatic integration | | **Browser Extensions** | Chrome and Firefox extensions for one-click scanning | | **Burp Suite Integration** | Send targets from Burp Suite directly to Jsmon | ## Who Is Jsmon For? | Audience | Use Case | | ----------------------------- | ---------------------------------------------------------------------------------- | | **Bug Bounty Hunters** | Automate recon, discover hidden assets, find leaked secrets | | **Penetration Testers** | Map attack surfaces, identify exposed APIs and misconfigurations | | **Security Researchers** | Analyze JavaScript files, track changes in web applications | | **Enterprise Security Teams** | Monitor external attack surface, detect credential leaks, audit third-party assets | ## Getting Help If you need assistance, reach out through any of these channels: * **Email**: [support@jsmon.sh](mailto:support@jsmon.sh) * **Documentation**: You're here! Browse the sidebar to find detailed guides. * **Community**: Join the Jsmon community for tips, updates, and discussions. # Integrations & Extensions Source: https://docs.jsmon.sh/integrations-and-extensions Extend Jsmon with browser extensions, Burp Suite, CLI, and API Jsmon integrates with your existing security workflow through browser extensions, a Burp Suite plugin, a command-line tool, and a full REST API. These tools let you scan targets on-the-fly, integrate Jsmon into your testing pipeline, and programmatically access your data. This section covers each integration in detail. # Keys & Secrets Source: https://docs.jsmon.sh/keys-and-secrets Detect leaked API keys, tokens, and credentials The Keys & Secrets section displays all leaked credentials, API keys, tokens, and other sensitive data discovered during your scans. Jsmon automatically detects common secret patterns in JavaScript files and other web assets. ## Overview The Keys & Secrets page provides a searchable, filterable table of all discovered secrets with the following columns: * **Secret** — The type of secret detected (e.g., AWS Access Key, GitHub Token, Stripe Key) * **Severity** — The risk level of the exposed secret * **Value** — The actual secret value found (partially masked for safety) * **Found On** — The date the secret was discovered ## Searching for Secrets The search bar at the top accepts pattern-based queries. You can search for specific secret prefixes such as: * `sk_live_` — Stripe live secret keys * `ghp_` — GitHub personal access tokens * `AKIA` — AWS access key IDs * Any custom pattern relevant to your target ## Filtering Use the available filters to narrow your results: * **Severity** — Filter by Critical, High, Medium, or Low severity * **Date** — Filter by the date range when secrets were discovered ## Exporting Click the **Export** button to download your secrets data for reporting or further analysis. ## Custom Modules Jsmon supports custom detection modules that allow you to define your own secret patterns. This feature is available on the **Recon** plan and above. Custom modules let you: * Define regex patterns for proprietary or uncommon secret formats * Set severity levels for custom detections * Apply custom modules across all your scans To access Custom Modules, click the **Custom Modules** button at the top of the Keys & Secrets page. Custom Modules are available on the Recon ($15/mo) and Recon Pro ($50/mo) plans. The free Starter plan does not include this feature. # Claude Source: https://docs.jsmon.sh/mcp-connector/claude Connect Jsmon to Claude Desktop and Claude Code using the MCP connector Connect Jsmon directly to **Claude** using the Model Context Protocol (MCP). Once connected, you can trigger scans, view results, manage workspaces, and interact with all Jsmon features — right from your Claude conversations. ## How It Works Jsmon provides a remote MCP server at: ```text theme={null} https://mcp.jsmon.sh/mcp ``` When you add this URL to Claude, it initiates an OAuth authentication flow. You'll be redirected to Jsmon's authorization page where you can configure permissions (read, write, delete, export) for the connection. Once authorized, Claude can interact with your Jsmon account directly. ## Connect to Claude Desktop Open the Claude Desktop app and go to **Settings** (click the gear icon or press `Cmd + ,` on macOS). In the Settings panel, click on **MCP Servers** (under the Developer or Integrations section). Click **Add Server** and enter the following: * **Name:** `Jsmon` * **Transport:** Select **Streamable HTTP** * **URL:** `https://mcp.jsmon.sh/mcp` Leave the authentication fields empty — OAuth handles this automatically. Click **Authenticate** when prompted. A browser window will open redirecting you to Jsmon's authorization page. Sign in to your Jsmon account and approve the requested permissions. Once connected, restart Claude Desktop. You can now ask Claude to interact with Jsmon — trigger scans, check results, manage workspaces, and more. ### Alternative: Manual Configuration You can also add Jsmon by editing the Claude Desktop config file directly: **macOS:** ```text theme={null} ~/Library/Application Support/Claude/claude_desktop_config.json ``` **Windows:** ```text theme={null} %APPDATA%\Claude\claude_desktop_config.json ``` Add the following to the config: ```json theme={null} { "mcpServers": { "jsmon": { "url": "https://mcp.jsmon.sh/mcp" } } } ``` Save the file and restart Claude Desktop. You'll be prompted to authenticate on first use. ## Connect to Claude Code (CLI) If you use [Claude Code](https://docs.anthropic.com/en/docs/claude-code), you can add Jsmon as an MCP server from the terminal: ```bash theme={null} claude mcp add jsmon --url https://mcp.jsmon.sh/mcp ``` Then authenticate: ```bash theme={null} claude mcp login jsmon ``` A browser window will open for OAuth authorization. Once complete, Jsmon tools are available in your Claude Code sessions. ## What You Can Do Once connected, you can ask Claude to: * **Run scans** — "Scan example.com for JavaScript files" * **View results** — "Show me secrets found in my last scan" * **Manage workspaces** — "List my workspaces" or "Create a new workspace" * **Check monitoring** — "What domains am I monitoring?" * **Export data** — "Export all API paths from workspace X" ## Permissions During OAuth authorization, you can configure the following scopes: | Scope | Description | | ---------- | -------------------------------------------------- | | **Read** | View scan results, workspaces, and account data | | **Write** | Trigger scans, create workspaces, update settings | | **Delete** | Remove workspaces, scan data, or monitored domains | | **Export** | Export scan results and intelligence data | You can update or revoke MCP permissions at any time from your Jsmon account settings. # Codex Source: https://docs.jsmon.sh/mcp-connector/codex Connect Jsmon to OpenAI Codex using the MCP connector Connect Jsmon to **OpenAI Codex** — both the CLI and desktop app — using the Model Context Protocol (MCP). Once connected, you can run scans, retrieve intelligence data, and manage your Jsmon workspaces directly from Codex conversations. ## How It Works Jsmon exposes a remote MCP server using the Streamable HTTP transport at: ```text theme={null} https://mcp.jsmon.sh/mcp ``` Codex supports OAuth-based authentication for remote MCP servers. When you add Jsmon, Codex opens a browser window for you to sign in and approve permissions — no API keys or tokens to manage manually. ## Connect via Codex CLI The fastest way to connect is using the Codex CLI: Run the following command in your terminal: ```bash theme={null} codex mcp add jsmon --url https://mcp.jsmon.sh/mcp ``` Trigger the OAuth login flow: ```bash theme={null} codex mcp login jsmon ``` A browser window will open. Sign in to your Jsmon account and approve the requested permissions (read, write, delete, export). Confirm the server is registered: ```bash theme={null} codex mcp list ``` You should see `jsmon` listed with a `connected` status. Launch Codex and start interacting with Jsmon. Ask it to scan targets, view results, or manage workspaces. ## Connect via Codex Desktop App In the Codex desktop app, go to **Settings** → **Integrations** → **MCP servers**. Click **+ Add server** and configure: * **Name:** `Jsmon` * **Transport:** Select **Streamable HTTP** * **URL:** `https://mcp.jsmon.sh/mcp` Leave the bearer token and header fields empty. Click **Authenticate**. A browser window will open for OAuth authorization. Sign in to your Jsmon account and approve permissions. Click **Save**, then restart Codex. Jsmon tools will now be available in your conversations. ## Manual Configuration (Optional) You can also edit the Codex config file directly at: ```text theme={null} ~/.codex/config.toml ``` Add the following: ```toml theme={null} [mcp_servers.jsmon] url = "https://mcp.jsmon.sh/mcp" auth = "oauth" ``` Then run `codex mcp login jsmon` to complete authentication. ## What You Can Do Once connected, ask Codex to: * **Scan targets** — "Scan example.com with Jsmon" * **View intelligence** — "Show secrets found in workspace X" * **Manage workspaces** — "List all my Jsmon workspaces" * **Monitor domains** — "What domains am I monitoring on Jsmon?" * **Export results** — "Export API paths from my latest scan" ## Permissions During OAuth authorization, you configure the following scopes: | Scope | Description | | ---------- | -------------------------------------------------- | | **Read** | View scan results, workspaces, and account data | | **Write** | Trigger scans, create workspaces, update settings | | **Delete** | Remove workspaces, scan data, or monitored domains | | **Export** | Export scan results and intelligence data | OAuth tokens refresh automatically. You can revoke access at any time from your Jsmon account settings. # Cursor Source: https://docs.jsmon.sh/mcp-connector/cursor Connect Jsmon to Cursor IDE using the MCP connector Connect Jsmon to **Cursor** — the AI-powered code editor — using the Model Context Protocol (MCP). Once connected, you can query scan results, look up secrets, check attack surface data, and manage your Jsmon workspaces without leaving your editor. ## How It Works Jsmon provides a remote MCP server at: ```text theme={null} https://mcp.jsmon.sh/mcp ``` Cursor supports remote MCP servers via the Streamable HTTP transport. You add the Jsmon MCP URL to your Cursor configuration, and on first use, an OAuth flow opens in your browser to authenticate with your Jsmon account. ## Setup Open Cursor and go to **Settings** → **MCP** (or press `Cmd + Shift + J` on macOS / `Ctrl + Shift + J` on Windows/Linux to open the MCP configuration). Click **+ Add new MCP server** and configure: * **Name:** `Jsmon` * **Type:** Select **Streamable HTTP** (or **URL**) * **URL:** `https://mcp.jsmon.sh/mcp` Save the configuration. When Cursor connects to the Jsmon MCP server for the first time, a browser window will open for OAuth authorization. Sign in to your Jsmon account and approve the requested permissions. Once authenticated, Jsmon tools are available in Cursor's AI chat and agent mode. Ask questions about your scan data, trigger new scans, or look up intelligence — all inline. ### Manual Configuration (Config File) You can also edit the MCP config file directly: **Global (all projects):** ```text theme={null} ~/.cursor/mcp.json ``` **Project-specific:** ```text theme={null} .cursor/mcp.json ``` Add the following: ```json theme={null} { "mcpServers": { "jsmon": { "url": "https://mcp.jsmon.sh/mcp" } } } ``` Save the file and restart Cursor. You'll be prompted to authenticate on first use. ## Use Cases for Developers Jsmon in Cursor is especially useful when you're coding and need quick access to security intelligence: * **Check for exposed secrets** — "Are there any leaked API keys in my workspace?" * **Review scan results while coding** — "Show me all API endpoints found on example.com" * **Validate domains** — "What subdomains does Jsmon know about for example.com?" * **Trigger scans** — "Scan this URL with Jsmon" while reviewing code * **Look up vulnerabilities** — "Show me security issues found in workspace X" ## Permissions During OAuth authorization, you configure the following scopes: | Scope | Description | | ---------- | -------------------------------------------------- | | **Read** | View scan results, workspaces, and account data | | **Write** | Trigger scans, create workspaces, update settings | | **Delete** | Remove workspaces, scan data, or monitored domains | | **Export** | Export scan results and intelligence data | Cursor supports both global and per-project MCP configurations. Use the global config for personal Jsmon access across all projects, or the project-level config for team setups. # Windsurf Source: https://docs.jsmon.sh/mcp-connector/windsurf Connect Jsmon to Windsurf IDE using the MCP connector Connect Jsmon to **Windsurf** (by Codeium) — the AI-powered IDE — using the Model Context Protocol (MCP). Once connected, you can access Jsmon's scan data, trigger scans, and manage workspaces directly from Windsurf's Cascade AI assistant. ## How It Works Jsmon provides a remote MCP server at: ```text theme={null} https://mcp.jsmon.sh/mcp ``` Windsurf supports remote MCP servers via HTTP transport. You add the Jsmon server URL to Windsurf's MCP config file, and authenticate through the OAuth flow on first connection. ## Setup Open Windsurf and go to **Settings** → **Cascade** → **Advanced Settings**. Make sure **MCP** is turned on. The MCP configuration file is located at: **macOS / Linux:** ```text theme={null} ~/.codeium/windsurf/mcp_config.json ``` **Windows:** ```text theme={null} %USERPROFILE%\.codeium\windsurf\mcp_config.json ``` Create the file if it doesn't exist. Add the following to your `mcp_config.json`: ```json theme={null} { "mcpServers": { "jsmon": { "serverUrl": "https://mcp.jsmon.sh/mcp" } } } ``` Windsurf uses `serverUrl` instead of `url` for remote HTTP servers. Using the wrong key will cause the connection to fail silently. Save the config file. Windsurf monitors the file for changes and picks up the new server automatically — no restart needed. On first use, an OAuth flow will open in your browser. Sign in to your Jsmon account and approve the requested permissions. Open Cascade (Windsurf's AI assistant) and start asking questions about your Jsmon data. You can trigger scans, view results, and manage workspaces inline. ## Use Cases Windsurf + Jsmon is ideal for developers who want security context while coding: * **Surface secrets during development** — "Check if any API keys were found on example.com" * **Review attack surface** — "What subdomains does Jsmon know about for my domain?" * **Scan while building** — "Scan this URL for JavaScript intelligence" * **Look up endpoints** — "Show me all API paths found in workspace X" * **Monitor domains** — "What domains am I monitoring on Jsmon?" ## Permissions During OAuth authorization, you configure the following scopes: | Scope | Description | | ---------- | -------------------------------------------------- | | **Read** | View scan results, workspaces, and account data | | **Write** | Trigger scans, create workspaces, update settings | | **Delete** | Remove workspaces, scan data, or monitored domains | | **Export** | Export scan results and intelligence data | Windsurf auto-detects config file changes — you don't need to restart the editor after editing `mcp_config.json`. # Monitoring Source: https://docs.jsmon.sh/monitoring Set up continuous monitoring and alerts for your targets Monitoring allows you to schedule recurring scans on your targets and receive notifications when new findings are detected. This is essential for maintaining ongoing visibility into your attack surface. ## Overview The Monitoring page displays all your active and paused monitors with the following information: | Column | Description | | ------------- | ------------------------------------------------ | | **Workspace** | The workspace the monitor belongs to | | **Asset** | The target domain or URL being monitored | | **Category** | The type of scan being performed | | **URLs** | Number of URLs covered by the monitor | | **Channel** | The notification channel (Email, Discord, Slack) | | **Time** | The monitoring schedule/frequency | | **Status** | Whether the monitor is Active or Paused | | **Last Run** | When the monitor last executed | ## Setting Up Monitoring To enable monitoring for a scan: Go to the **Scans** page in your workspace. Find the scan you want to monitor in the scan list. Toggle the monitoring switch in the **Monitoring** column to enable it. Set up your preferred notification channel. Jsmon supports: * **Email** — Receive alerts directly in your inbox * **Discord** — Get notifications in a Discord channel via webhook * **Slack** — Receive alerts in a Slack channel ## Managing Monitors From the Monitoring page you can: * **Toggle Monitoring Notifications** — Enable or disable all notifications globally using the toggle at the top * **Search** — Find specific monitors by target or workspace * **Filter** — Filter by workspace, status (Active/Paused), category, or notification channel * **Disable All** — Quickly disable all active monitors using the **Disable All** button ## Notification Channels Jsmon supports three notification channels for monitoring alerts: | Channel | Availability | | ----------- | ----------------------------- | | **Email** | All plans (including Starter) | | **Discord** | Recon and Recon Pro plans | | **Slack** | Recon and Recon Pro plans | The free Starter plan supports email alerts only. Upgrade to Recon or Recon Pro for Discord and Slack integration. # My Details Source: https://docs.jsmon.sh/my-details Manage your personal profile and account settings The **My Details** tab lets you view and update your personal profile information within Jsmon. ## Profile Information Your profile page displays: | Field | Description | | ------------------- | ------------------------------------------------------ | | **Name** | Your display name across the platform | | **Email** | The email address associated with your account | | **Avatar** | Your profile picture (synced from your login provider) | | **Account Created** | When your Jsmon account was first created | ## Updating Your Profile ### Navigate to Settings Click your profile icon in the bottom-left corner of the sidebar, then select **Settings**. ### Open My Details You'll land on the **My Details** tab by default. ### Edit Your Information Update your name or other editable fields, then click **Save Changes**. ## Account Security Since Jsmon uses OAuth-based authentication (Google, GitHub), your password and primary email are managed through your identity provider. To change your login credentials, update them directly with Google or GitHub. If you signed up with Google, your profile picture and name are pulled from your Google account automatically. ## Deleting Your Account To delete your Jsmon account and all associated data, contact support at [**support@jsmon.sh**](mailto:support@jsmon.sh). Account deletion is permanent and removes all workspaces, scan history, and saved results. Account deletion cannot be undone. Export any important scan results before requesting deletion. # Pricing & Plans Source: https://docs.jsmon.sh/pricing-and-plans Choose the right Jsmon plan for your security needs Jsmon offers flexible pricing that scales from solo researchers to enterprise security teams. All plans include access to the core scanning and reconnaissance features, with higher tiers unlocking advanced capabilities. ## Plans Overview | Feature | Starter (Free) | Recon (\$15/mo) | Recon Pro (\$50/mo) | | -------------------------- | --------------- | ------------------------ | ------------------------ | | Price | Free (one-time) | \$15/month or \$150/year | \$50/month or \$500/year | | Scan Credits | 1,500 lifetime | 25,000/month | 100,000/month | | Monthly Scans | — | 10,000/month | Included | | Findings & Leaked Secrets | Yes | Yes | Yes | | WAF Bypass | No | Yes | Yes | | Authenticated Scans | No | Yes | Yes | | Custom Modules | No | Yes | Yes | | Workspace Sharing | No | Yes | Yes | | Alert Channels | Email only | Email, Discord, Slack | Email, Discord, Slack | | Priority Scan Queue | No | No | Yes | | Advanced Reporting Exports | Yes | Yes | Yes | | Dedicated Slack Support | No | Yes | Yes | ## Starter (Free Trial) The Starter plan is a one-time free trial that lets you explore Jsmon without a credit card. It includes 1,500 lifetime scan credits and access to basic scanning, findings, and leaked secrets detection. Ideal for trying out the platform before committing to a paid plan. ## Recon — \$15/month The Recon plan is designed for bug bounty hunters, pentesters, and security researchers who need robust, ongoing scanning. It includes 25,000 monthly scan credits, WAF bypass, authenticated scans, custom modules, workspace sharing, and multi-channel alerts (Email, Discord, Slack). ## Recon Pro — \$50/month The Recon Pro plan is built for power researchers running large programs or scanning multiple targets at scale. It includes 100,000 monthly scan credits, everything in Recon, plus priority scan queue, advanced reporting exports, and dedicated Slack support. ## Scan Credits Add-On Need more credits? You can purchase additional scan credits as an add-on package: **\$10 for 15,000 credits**. Credits are added instantly to your account. Free account starts with 1500 credits and 10 alert scans monthly — no credit card required. Annual billing is available for both Recon and Recon Pro plans, saving you the equivalent of two months. # Reconnaissance Source: https://docs.jsmon.sh/reconnaissance Explore discovered assets across 20+ categories The Reconnaissance section provides a comprehensive view of all assets and data discovered during your scans. Jsmon automatically categorizes findings into over 20 distinct categories, making it easy to explore and analyze your target's attack surface. ## Layout The Reconnaissance page uses a two-panel layout: * **Left Panel** — A list of all categories with item counts for each * **Right Panel** — The data for the currently selected category, with search, filtering, and export options ## Categories Jsmon organizes reconnaissance data into the following categories: | Category | Description | | ----------------------- | -------------------------------------------------------------------------- | | **API Paths** | Discovered API endpoints and routes | | **Headers** | HTTP response headers collected during scanning | | **URLs** | All URLs discovered during the crawl | | **Domains** | Subdomains and related domains found | | **AWS Assets** | Amazon Web Services resources (S3 buckets, CloudFront distributions, etc.) | | **IP Addresses** | IP addresses associated with the target | | **Emails** | Email addresses found in the target's assets | | **S3 Bucket Takeovers** | S3 buckets vulnerable to subdomain takeover | | **GQL Queries** | GraphQL query operations discovered | | **GQL Mutations** | GraphQL mutation operations discovered | | **GQL Fragments** | GraphQL fragment definitions found | | **Parameters** | URL and form parameters identified | | **Node Modules** | JavaScript packages and dependencies detected | | **NPM Confusion** | Packages potentially vulnerable to dependency confusion attacks | | **GUIDs** | Globally Unique Identifiers found in assets | | **Vulnerabilities** | Security vulnerabilities identified during scanning | | **Localhost** | References to localhost or internal addresses | | **Expired Domains** | Domains with expired registrations (potential takeover targets) | | **Social Media URLs** | Links to social media profiles and pages | | **Filtered Port URLs** | URLs with non-standard ports | | **File Extension URLs** | URLs organized by file extension type | ## Working with Reconnaissance Data For each category, you can: * **Search** — Use the search bar to filter results within the selected category * **Filter by File Type** — Narrow results by specific file types * **Export** — Download the data for offline analysis or reporting Reconnaissance data is collected automatically during domain scans and is retained within the workspace for future reference. Each scan adds to the existing reconnaissance data, building a comprehensive picture of your target over time. # Scan Options Source: https://docs.jsmon.sh/scan-options Configure advanced settings for your scans Jsmon provides several advanced options to customize your scans. Access them by clicking the **Options (Depth, Headers, Extensions)** button on the Scans page. ## File Extensions Choose which file types to include in your scan. The default extensions are: `.html` `.php` `.txt` `.xml` `.json` `.map` `.xhtml` `.aspx` You can add custom extensions by typing them into the extensions field. This is useful for targeting specific file types relevant to your assessment. ## URL Extraction Depth Set the crawl depth to control how deep Jsmon follows links during scanning. The depth ranges from **1 to 4 levels**: | Depth | Description | | ----- | ------------------------------------------------- | | **1** | Only scans the target URL and its direct links | | **2** | Follows links one level deeper | | **3** | Follows links two levels deeper | | **4** | Maximum depth — follows links three levels deeper | Higher depth values discover more content but consume more credits and take longer to complete. ## WAF Bypass Enable the **WAF Bypass** toggle to use techniques that help scan targets protected by Web Application Firewalls. When enabled, Jsmon attempts to bypass common WAF protections to reach the underlying content. WAF Bypass is available on the Recon and Recon Pro plans only. ## Keywords Add keywords to filter and prioritize your scan results. Click **Add Keywords** to enter terms that are relevant to your assessment. Results matching your keywords will be highlighted or prioritized in the output. ## Custom Headers Add custom HTTP headers to your scan requests. This is useful for: * **Authentication** — Add `Authorization` headers to scan authenticated areas * **API Keys** — Include API key headers required by the target * **Custom Tokens** — Add any custom headers needed for access To add a header: 1. Enter the **Key** (header name) in the left field 2. Enter the **Value** in the right field 3. Click **Add** to include it You can add multiple headers. Use **All Headers** to view and manage all configured headers. Authenticated scans (using custom headers for authentication) are available on the Recon and Recon Pro plans. # Settings Source: https://docs.jsmon.sh/settings Manage your profile, subscription, API keys, and extensions The Settings page lets you manage your account details, subscription, API access, and browser extensions. Access it by clicking your profile avatar in the top-right corner and selecting **Settings**. Settings is organized into four tabs: * **My Details** — Update your name, email, and profile photo * **Subscription Details** — View and manage your current plan * **API Keys / Credits** — Manage your API key and view credit balances * **Extensions** — Download browser extensions and integrations Each tab is covered in detail in the pages below. # Sharing Workspaces Source: https://docs.jsmon.sh/sharing-workspaces Invite team members and manage workspace access Jsmon allows you to share workspaces with other users, enabling team collaboration on security assessments and bug bounty programs. Workspace sharing is available on the **Recon** and **Recon Pro** plans. The free Starter plan does not include this feature. ## Inviting Team Members To share a workspace: Click the **Share Workspace** button in the top-right corner of any workspace page. In the Share workspace dialog, enter the email addresses of the people you want to invite. You can enter multiple addresses separated by commas. Use the permission dropdown to select the access level for the invited users. Available permission levels include: * **Read** — View scan results, reconnaissance data, and secrets (cannot modify) Click the **Invite** button to send the invitation. The invited users will receive a notification and can access the workspace from their Workspaces page. ## Managing Access The Share workspace dialog has two tabs: * **Invitations** — Shows pending invitations that haven't been accepted yet * **Shared** — Shows current members who have access to the workspace, along with their permission level From the Shared tab, you can view all members and their permissions in a table with **Members** and **Permissions** columns. ## Identifying Shared Workspaces On the Workspaces page, workspaces that have been shared with you by others display an **Invited** badge on the workspace card, making it easy to distinguish between your own workspaces and those shared with you. # Subscription & Plans Source: https://docs.jsmon.sh/subscriptions-and-plans Manage your subscription, upgrade or downgrade your plan, and view billing The **Subscription** tab in Settings lets you view your current plan, upgrade or downgrade, and manage billing. ## Current Plan Overview | Detail | Description | | --------------------- | ------------------------------------------------ | | **Plan Name** | Your current tier (Starter, Recon, or Recon Pro) | | **Status** | Active, Trial, or Expired | | **Billing Cycle** | Monthly renewal date | | **Credits Remaining** | How many scan credits you have left this cycle | ## Available Plans | Feature | Starter (Free) | Recon (\$15/mo) | Recon Pro (\$50/mo) | | ----------------- | :------------: | :-------------: | :-----------------: | | Scans per month | 100 | 5,000 | 20,000 | | Workspaces | 1 | 5 | Unlimited | | Workspace sharing | — | — | ✓ | | Monitoring | — | ✓ | ✓ | | API access | — | ✓ | ✓ | | Custom modules | — | — | ✓ | | Priority support | — | — | ✓ | ## Upgrading Your Plan ### Go to Settings → Subscription Open the Settings page and click the **Subscription** tab. ### Select a Plan Review the available plans and click **Upgrade** on the one you want. ### Complete Payment Enter your payment details through the secure Stripe checkout. Your new plan activates immediately. ## Adding Extra Credits If you run out of scan credits mid-cycle, you can purchase a **Credits Add-on** for **\$10 per 15,000 credits**. These credits are added on top of your plan's monthly allocation and do not expire at the end of the billing cycle. Credits from the add-on pack roll over month to month until used, unlike your plan's base credits which reset each cycle. ## Downgrading or Cancelling You can downgrade to a lower plan or cancel your subscription at any time. Your current plan remains active until the end of the billing period. When downgrading, excess workspaces beyond the new plan's limit become read-only, monitoring schedules may be paused, and API access may be restricted. Downgrading does not trigger a refund for the current billing period. The new plan takes effect at the next renewal. # Understanding Scan Credits Source: https://docs.jsmon.sh/understanding-scan-credits Learn how the credit system works and how to manage your credits Jsmon uses a credit-based system to meter scan usage. Credits are consumed each time Jsmon processes and analyzes URLs and assets during a scan. ## Credit Allocations by Plan | Plan | Credits | Reset Frequency | | ----------------------- | ------- | ------------------- | | **Starter (Free)** | 1,500 | Lifetime (no reset) | | **Recon (\$15/mo)** | 25,000 | Monthly | | **Recon Pro (\$50/mo)** | 100,000 | Monthly | ## How Credits Are Consumed Credits are deducted based on the number of URLs and assets analyzed during a scan. A single domain scan may consume varying amounts of credits depending on the size of the target — a small website with a few pages will use fewer credits than a large web application with thousands of JavaScript files. ## Checking Your Balance You can view your current credit balance in two places: * **Scans page** — The green **Scan Credits** badge at the top shows your remaining credits * **Settings → API Keys / Credits** — Displays detailed credit information including your total allocation and usage ## Purchasing Additional Credits If you run out of credits before your monthly reset, you can purchase add-on credit packs: **\$10 = 15,000 additional credits** Add-on credits are available to all plans and are added to your balance immediately. You can purchase them from **Settings → Subscription Details** or from the pricing page at [jsmon.sh/pricing](https://jsmon.sh/pricing). ## API Credits If you use the Jsmon API, API calls also consume credits. The credit system works the same way: 1. **Subscribe** to a plan to receive your monthly credit allocation 2. **Use your API key** to make API calls 3. **Credits are deducted** based on the operations performed 4. **Auto-renew** — Credits reset automatically at the start of each billing cycle All plans start with 500 free scans and 10 alert scans monthly, even before purchasing a plan. No credit card required. # Understanding Scan Results Source: https://docs.jsmon.sh/understanding-scan-results Navigate and interpret your scan findings After a scan completes, you can view its results by clicking on the scan row in the scan list. A detail panel opens showing comprehensive findings organized into tabs. ## Scan Detail Panel The detail panel header shows: * **Target URL** — The domain or URL that was scanned * **Scan Date** — When the scan was performed * **Scan Configuration** — A summary of options used (depth, extensions, etc.) * **Version Dropdown** — "All versions" selector to view results from previous scan runs ## Result Tabs Results are organized into three tabs, each with a count badge showing the number of findings: ### Overview The Overview tab provides a summary of the scan with four metric cards: | Metric | Description | | ----------------- | -------------------------------------------- | | **API Endpoints** | Number of API endpoints discovered | | **URLs Scanned** | Total URLs that were analyzed | | **Issues** | Number of security issues found | | **PII Data** | Personally identifiable information detected | Below the cards, a list of discovered API endpoints and URLs is displayed. ### Secrets The Secrets tab lists all leaked credentials, API keys, and tokens found during the scan. Each secret shows the type, severity, value, and the file where it was found. ### Reconnaissance The Reconnaissance tab displays all assets discovered during the scan, organized into the same categories available on the main Reconnaissance page. ## Actions From the scan detail panel, you can: * **Rescan** — Re-run the scan with the same configuration to check for changes * **Download** — Export the results for offline analysis * **View Previous Versions** — Use the version dropdown to compare results across different scan runs ## Failed Scans If a scan fails, the detail panel will display: * A **Scan Failed** message * The **Reason for Failure** explaining what went wrong * A **Report it to Us** button to notify the Jsmon team about the issue Common reasons for scan failure include DNS resolution errors, connection timeouts, and access restrictions. # URL Scan Source: https://docs.jsmon.sh/url-scan Scan a specific URL for analysis URL Scan lets you scan a specific URL rather than an entire domain. This is useful when you want to analyze a particular page, JavaScript file, or API endpoint without crawling the full domain. ## How to Run a URL Scan 1. Navigate to the **Scans** page in your workspace 2. Click the **+** button next to Domain Scan to open the scan type selector 3. Select **URL Scan** from the dropdown 4. Enter the full URL you want to scan (e.g., `https://example.com/api/v1/config.js`) 5. Optionally configure scan options 6. Click the **Start Scan** button ## When to Use URL Scan URL Scan is ideal for: * Analyzing a specific JavaScript file you've identified * Scanning a particular API endpoint * Checking a single page for leaked secrets * Quick targeted analysis without using credits on a full domain crawl ## Results URL Scan results follow the same format as Domain Scan results, with Overview, Secrets, and Reconnaissance tabs. The scope of findings is limited to the specific URL you scanned. # Your First Scan Source: https://docs.jsmon.sh/your-first-scan Run your first domain scan and explore the results This guide walks you through running your first domain scan in Jsmon and understanding the results. From the Workspaces page, click **Open** on the workspace you want to use. If you haven't created one yet, click **+** to create a new workspace first. You'll be taken to the **Scans** page by default. At the top, you'll see a domain input field with the placeholder "Enter a domain to scan". Type the target domain you want to scan (e.g., `example.com`) into the input field. Make sure **Domain Scan** is selected as the scan type. Click **Options (Depth, Headers, Extensions)** to customize your scan: * **Extensions** — Choose which file types to scan (.html, .php, .js, .json, etc.) * **URL Extraction Depth** — Set the crawl depth from 1 to 4 levels * **WAF Bypass** — Enable to scan behind Web Application Firewalls (paid plans only) * **Keywords** — Add keywords to filter results * **Custom Headers** — Add authentication or custom headers to your requests Click the **Start Scan** button (the blue send icon). Your scan will be queued and begin processing. You can monitor its status in the scan list below. Once the scan completes (status shows as "Completed"), click on the scan row to open the detail panel. You'll see: * **Overview** — Summary cards showing API Endpoints, URLs Scanned, Issues, and PII Data found, plus a list of discovered endpoints * **Secrets** — Any leaked API keys, tokens, or credentials found * **Reconnaissance** — All discovered assets categorized by type Your Scan Credits balance is displayed at the top of the Scans page. Each scan consumes credits based on the number of URLs analyzed. The free Starter plan includes 1,500 lifetime credits. ## What Happens During a Scan? When you initiate a domain scan, Jsmon performs the following steps: 1. **DNS Resolution** — Resolves the target domain and identifies associated IP addresses 2. **URL Discovery** — Crawls the domain to discover all accessible URLs and JavaScript files 3. **Asset Extraction** — Parses JavaScript files and web pages to extract API endpoints, parameters, domains, and other assets 4. **Secret Detection** — Scans for leaked API keys, tokens, credentials, and other sensitive data 5. **Vulnerability Analysis** — Identifies common vulnerabilities and security misconfigurations 6. **Categorization** — Organizes all findings into the Reconnaissance categories for easy browsing ## Scan Statuses Your scan will show one of these statuses: | Status | Description | | ------------- | ----------------------------------------------------------- | | **Queued** | Scan is waiting to be processed | | **Running** | Scan is actively crawling and analyzing the target | | **Completed** | Scan finished successfully — click to view results | | **Failed** | Scan encountered an error — click to see the failure reason | If a scan fails, you can view the failure reason in the scan detail panel and click **Report it to Us** to notify the Jsmon team.