Skip to content
| Marketplace
Sign in
Visual Studio Code>Linters>ApyGuard APIScout — API Explorer & OpenAPI ReadinessNew to Visual Studio Code? Get it now.
ApyGuard APIScout — API Explorer & OpenAPI Readiness

ApyGuard APIScout — API Explorer & OpenAPI Readiness

Apyguard

|
22 installs
| (1) | Free
Discover endpoints, measure OpenAPI readiness, review findings, generate endpoint-specific AI guidance, compare API changes, and export OpenAPI without leaving VS Code.
Installation
Launch VS Code Quick Open (Ctrl+P), paste the following command, and press enter.
Copied to clipboard
More Info

APIScout — API Explorer & OpenAPI Readiness for VS Code

Discover REST API endpoints in Express, FastAPI, Django, Flask, NestJS, and Spring Boot, measure documentation readiness, review source-backed findings, and export OpenAPI (Swagger) without leaving VS Code.

APIScout turns the backend project in your current workspace into a practical API inventory. Core discovery runs locally, so you can inspect a branch that has never been deployed, find documentation gaps, and trace endpoints and findings back to their handlers.

The workflow goes beyond inventory: use a weighted OpenAPI Readiness score, compare scans against a previous result or accepted baseline, review or suppress findings with reasons, and optionally generate endpoint-specific descriptions and remediation guidance with your own AI provider.

Scanning, exporting and reviewing work without an account. You sign in to ApyGuard only to send results: the first Send to ApyGuard opens your browser, you sign in and choose Authorize, and VS Code continues on its own. The extension keeps the access token ApyGuard issues in the VS Code secrets API, and Sign Out revokes it. AI remains optional; when enabled, requests are sent to the provider you configure. Documentation is uploaded to ApyGuard only when you send it.

Demo

ApyGuard APIScout demo

What You Can Do

  • discover paths, methods, handlers, and source evidence from supported backend projects
  • measure documentation completeness with a weighted OpenAPI Readiness score
  • generate endpoint-specific OpenAPI descriptions and short remediation suggestions with optional AI
  • add generated descriptions, suggestions, and deterministic fixes to the real handler as TODO(APIScout) comments
  • inspect finding confidence, evidence, sensitivity, and suggested fixes from Priority Finding cards
  • open the real handler or controller from a finding instead of stopping at the route declaration
  • mark findings reviewed, suppress them with a required reason, or reopen them later
  • keep reviewed and suppressed findings visible with distinct cards, icons, badges, and suppression reasons
  • see what needs attention first in the API Explorer: findings, documentation gaps with the operations behind them, changes grouped by operation, and operations grouped by endpoint
  • filter by method, path, severity, review state, or changed operations and sort by path, file, or risk
  • compare the latest inventory with the previous scan or an accepted API baseline
  • identify added, removed, and changed endpoints and export the comparison as Markdown
  • detect stale results when source files change and rescan from the Explorer
  • export OpenAPI as .yaml, .yml, or .json
  • preview the latest scan with a bundled, theme-aware Swagger UI and use Try it out
  • send requests from a searchable endpoint playground with path, query, header, OpenAPI authentication, and body inputs
  • validate and format JSON, inspect redirects and final URLs, review bounded responses, or copy requests as cURL
  • use grouped CodeLens actions when multiple endpoints share the same source location
  • explain individual endpoints and merge generated documentation into an OpenAPI file

Best For

  • teams documenting existing APIs that are ahead of their specs
  • engineers validating API inventory before publishing OpenAPI
  • security and platform teams mapping exposed routes
  • developers working locally who want a source-driven API workflow

OpenAPI Readiness

The Scan Summary presents a weighted documentation score instead of treating every gap as equally important. Checks cover:

  • operation descriptions
  • request parameters and request bodies where applicable
  • documented responses
  • authentication and security declarations
  • unique operation IDs
  • source confidence for routes that need manual review

Each readiness issue links to an affected endpoint. Missing descriptions can produce ready-to-use endpoint-specific text, while other gaps can request a short AI suggestion.

Finding Review Workflow

Priority Finding cards provide direct access to Open Source, Suggested Fix, and Generate AI Suggestion.

  • Reviewed findings stay visible with a green badge and Explorer icon.
  • Suppressed findings stay visible with a separate icon and their required suppression reason.
  • Reopen Finding returns either state to the active review queue.
  • confidence and evidence show why APIScout reported the finding.

APIScout does not apply implementation fixes. It provides guidance and lets the user explicitly add the selected text as a source comment.

Add as TODO

Generated OpenAPI descriptions, AI suggestions, and built-in suggested fixes include an Add as TODO action. APIScout resolves the real endpoint handler, inserts a language-appropriate TODO(APIScout) comment, and opens the edited file for review.

TODO insertion currently supports Python, JavaScript, TypeScript, Java, and Kotlin source files. Long suggestions are wrapped for readability and duplicate TODO comments are rejected.

Scan History and API Changes

APIScout compares each scan with the previous result or an accepted baseline. The Explorer and Scan Summary surface added, removed, and changed API contract details, including potentially breaking changes. Comparisons can be exported as Markdown for pull requests and team review.

Request and response bodies are compared down to the properties of nested and $ref models: a property that was added, removed, given another type, or made required or optional is listed with its path, such as [].customer.address.zipCode. A body change is marked potentially breaking when a client written against the previous scan may fail: a new required request property or one made required, a removed response property or one made optional, and any type change; the same goes for a whole request or response body. A renamed property shows as a removal and an addition, so renaming a response property is marked too.

Parameters are marked potentially breaking when they change, when they are removed (the server then ignores them, so a client that filters or pages with one gets a different response), and when a new query, header, or cookie parameter is required. A path parameter added or removed under the same path is not marked: the path's own variables decide what a client sends, so such a change only corrects the document.

Supported Frameworks

  • Django
  • Express
  • FastAPI
  • Flask
  • NestJS
  • Spring Boot (Java)

The engine can also work with existing OpenAPI specification files as input.

Typical Workflow

  1. Open a supported API project folder in VS Code.
  2. Run ApyGuard APIScout: Run Doctor.
  3. Run ApyGuard APIScout: Scan API Project.
  4. Review OpenAPI Readiness, Priority Findings, source evidence, and API changes in the Scan Summary.
  5. Mark findings reviewed or suppressed, request optional AI guidance, and add useful results as TODO comments.
  6. Accept a baseline, export the change report, or export OpenAPI when the inventory is ready.
  7. Send to ApyGuard from the APIScout view. The first time, sign in through your browser, name the API, and say where it runs; after that, sending is one click.

Guided Onboarding

After you install APIScout, the Get Started with APIScout guide opens. It takes you from install to your first scan in six steps, and its step list shows which ones are done:

  1. Welcome: what APIScout does and what stays on your machine.
  2. Your project: open the folder with your backend code. When VS Code asks whether you trust the folder's authors, choose Yes; APIScout doesn't run in Restricted Mode. Once the folder is open, the guide continues with the next step.
  3. Check your setup: Doctor's checks run in the guide and show what passed and what to fix.
  4. Optional: AI explanations: choose a provider and model, or continue without AI.
  5. First scan: the results appear in the guide, with the Scan Summary, the API Explorer, and OpenAPI export one click away.
  6. Optional: send to ApyGuard, the only step that needs an account.

To open the guide again, run ApyGuard APIScout: Open Getting Started Guide, select Getting Started Guide in the API Explorer before your first scan, or pick it from the API Explorer's ... menu. The guide doesn't open on install when the VS Code setting workbench.welcomePage.walkthroughs.openOnInstall is off.

Doctor Checks

ApyGuard APIScout: Run Doctor validates the local-first workflow before scan and export:

  • workspace folder availability and supported framework hints
  • Python runtime reachability, only when apyguardApiScout.enginePath points to your own engine; the bundled engine doesn't use Python
  • engine path resolution and CLI boot
  • AI configuration readiness, including missing API keys or insecure TLS settings

Commands

  • ApyGuard APIScout: Scan API Project
  • ApyGuard APIScout: Continue Workflow
  • ApyGuard APIScout: Rescan Outdated Results
  • ApyGuard APIScout: Review Findings
  • ApyGuard APIScout: Show Scan Summary
  • ApyGuard APIScout: Preview OpenAPI with Swagger UI
  • ApyGuard APIScout: Open Request Playground
  • ApyGuard APIScout: Accept Current API Baseline
  • ApyGuard APIScout: Export API Changes as Markdown
  • ApyGuard APIScout: Export OpenAPI
  • ApyGuard APIScout: Run Doctor
  • ApyGuard APIScout: Explain This API Endpoint
  • ApyGuard APIScout: Merge Explained Endpoint Into OpenAPI
  • ApyGuard APIScout: Configure AI
  • ApyGuard APIScout: Open Settings
  • ApyGuard APIScout: Open Getting Started Guide
  • Filter API Explorer
  • Sort API Explorer
  • Clear API Explorer Filters
  • ApyGuard APIScout: Set AI API Key
  • ApyGuard APIScout: Send to ApyGuard
  • ApyGuard APIScout: Sign In to ApyGuard
  • ApyGuard APIScout: Sign Out of ApyGuard
  • ApyGuard APIScout: Configure Local AI
  • ApyGuard APIScout: Clear AI API Key

Requirements

  • VS Code 1.90.0 or newer
  • a workspace folder open in VS Code

The extension ships its scan engine as a native executable, so you don't need Python. Python 3.9 or newer is needed only when apyguardApiScout.enginePath points to your own copy of the engine.

Setup

Recommended in-product setup

For most Marketplace users, the easiest way to get started is from the extension UI:

  1. Open the API Explorer sidebar.
  2. Use the view actions to scan the project, export OpenAPI, or open the settings screen.
  3. Use ApyGuard APIScout: Open Settings to manage AI and batching settings from the built-in settings screen.
  4. Return to the sidebar when you want to run the next scan or export.

This is the recommended day-to-day workflow because it keeps setup and execution in one place.

Python

You don't need Python with the bundled engine. APIScout runs the engine with Python 3.9 or newer only when apyguardApiScout.enginePath points to your own copy of it, or when you run the extension from source. Then, if the interpreter APIScout finds isn't the one you want, set:

{
  "apyguardApiScout.pythonPath": "/absolute/path/to/python"
}

AI

AI-assisted enrichment is optional.

Hosted providers currently supported:

  • Gemini
  • Together AI
  • OpenAI
  • Azure AI / Foundry
  • Anthropic

Recommended setup path:

  1. Open the API Explorer sidebar.
  2. Click the settings action or run ApyGuard APIScout: Open Settings.
  3. Configure your main AI and batching preferences in the settings screen.
  4. Run ApyGuard APIScout: Set AI API Key only when you need to store or update a hosted provider key.

Manual Command Palette path:

  1. Run ApyGuard APIScout: Configure AI.
  2. Choose a provider and model.
  3. Run ApyGuard APIScout: Set AI API Key.

For local AI, the recommended manual path is:

  1. Run ApyGuard APIScout: Configure Local AI.
  2. Select the protocol adapter your local gateway exposes.
  3. Set the base URL for that endpoint.

After that, use ApyGuard APIScout: Open Settings if you want to adjust batching or the rest of the AI-related settings in one place.

Supported local adapters:

  • openai
  • gemini
  • anthropic
  • together

API keys are stored securely with the VS Code secrets API.

Hosted providers supported by the extension:

  • gemini
  • together
  • openai
  • azure
  • anthropic

Key Settings

You can manage these directly in VS Code settings, but Marketplace users will usually have the best experience by opening the built-in settings screen with ApyGuard APIScout: Open Settings.

  • apyguardApiScout.pythonPath: Python 3.9+ interpreter used to run the engine
  • apyguardApiScout.enginePath: optional absolute override for the engine root
  • apyguardApiScout.outputFileName: default export filename
  • apyguardApiScout.authEnabled: enables or disables the browser handoff to the ApyGuard web auth flow
  • apyguardApiScout.apiUrl: ApyGuard API the extension signs in to and sends discovery results to (default https://api.apyguard.com)
  • apyguardApiScout.appUrl: ApyGuard web app the extension signs in through and links to (default https://app.apyguard.com)
  • apyguardApiScout.authLoginUrl: browser login URL for ApyGuard web auth; leave empty to use appUrl with /auth/login
  • apyguardApiScout.aiEnabled: enables or disables AI-assisted scan and export enrichment
  • apyguardApiScout.aiProvider: provider selection
  • apyguardApiScout.aiBaseUrl: custom provider or local gateway URL
  • apyguardApiScout.aiLocalAdapter: local protocol adapter
  • apyguardApiScout.aiModel: model name override
  • apyguardApiScout.aiCaBundlePath: CA bundle path for AI HTTPS requests
  • apyguardApiScout.aiAllowInsecureTls: disables TLS verification for local testing and defaults to false
  • apyguardApiScout.aiDebugEnabled: writes AI debug logs
  • apyguardApiScout.aiDebugLogDir: workspace-relative AI debug log directory
  • apyguardApiScout.aiBatchSize: endpoints per AI inspection batch
  • apyguardApiScout.aiMaxConcurrentFlows: maximum parallel AI inspection flows

Example:

{
  "apyguardApiScout.pythonPath": "/absolute/path/to/.venv/bin/python",
  "apyguardApiScout.outputFileName": "openapi.generated.yaml",
  "apyguardApiScout.aiEnabled": true,
  "apyguardApiScout.aiProvider": "azure",
  "apyguardApiScout.aiBaseUrl": "https://your-resource.services.ai.azure.com/openai/v1",
  "apyguardApiScout.aiModel": "your-deployment-name"
}

For an on-premises ApyGuard installation, set the API and app URLs in your user settings. They are read from user settings only, so a workspace's .vscode/settings.json can't redirect your access token or sign-in; your token is sent only to the API that issued it, and you sign in again after changing apiUrl:

{
  "apyguardApiScout.apiUrl": "https://apyguard.example.internal",
  "apyguardApiScout.appUrl": "https://apyguard.example.internal"
}

Azure base URL notes:

  • Legacy Azure OpenAI: https://your-resource.openai.azure.com
  • OpenAI v1 on Azure or Foundry: https://your-resource.openai.azure.com/openai/v1 or https://your-resource.services.ai.azure.com/openai/v1
  • Foundry Models API: https://your-resource.services.ai.azure.com/models

API Explorer

After a scan, the API Explorer sidebar puts what needs attention first:

  • the scan row names the framework and counts endpoints (unique paths) and operations (an HTTP method on a path); click it to open the Scan Summary
  • Findings are grouped by severity; each row starts with its operation, such as POST /api/account, followed by the kind of finding, such as Personal data
  • Documentation lists the readiness gaps, such as Missing description, with the operations behind each one
  • Changes since previous scan (or since baseline) has a row for each changed operation with its changes inside, potentially breaking ones first
  • Operations groups operations by endpoint and lists each endpoint's methods on its row; an operation's icon takes the color of its highest finding

Filters and sorting help with large inventories:

  • the method, route scope, path text, and changed-only filters narrow every section; the severity and review-state filters narrow findings
  • the active filters show above the tree
  • sort by path, by source file, or by risk, which puts endpoints with higher findings first

Local-First Behavior

APIScout runs core discovery and analysis locally inside your VS Code environment.

That means:

  • source code is scanned from your current workspace
  • the Python engine runs on your machine
  • you can disable AI and use engine-only workflows
  • optional AI requests go to the provider configured by the user
  • ApyGuard asset creation or documentation import uploads data only after an explicit user action
  • local development builds can point to a sibling ../core-engine

Swagger Preview and Request Playground

After a scan, run ApyGuard APIScout: Preview OpenAPI with Swagger UI to render the latest generated document. Swagger UI is bundled with the extension and does not load scripts or styles from a CDN. The preview follows the active VS Code light or dark theme, resolves local OpenAPI $ref values, and uses the configured apyguardApiScout.analyzedApiUrl as its API server. Try it out uses Swagger UI's standard browser request flow, so the target API must explicitly allow the VS Code webview origin through its CORS policy. Keep CORS restricted to trusted development origins instead of enabling every origin.

Use the play action on an Explorer endpoint, or run ApyGuard APIScout: Open Request Playground, to open a searchable collection of every discovered endpoint. The request sits above the response, the divider between them can be dragged, and the endpoint list can be collapsed. Configure params, auth, headers, and body in dedicated tabs; the playground fills documented parameter and JSON body examples, marks required parameters, and shows the resolved URL as you type. Additional query parameters and headers are edited as rows that can be switched off individually. Each endpoint keeps its own draft while the panel is open, and opening another endpoint or rescanning updates the panel without discarding drafts. Press Ctrl+Enter (Cmd+Enter on macOS) to send, and use Copy as for cURL, JavaScript fetch, Python requests, HTTPie, or a .http file.

Environments, such as Local and Staging, each have a base URL and their own saved credentials. Credentials entered in the Auth tab are stored in VS Code secret storage for the active environment and shared by every endpoint that uses the same security scheme; a single endpoint can override them. Log in… calls a detected login endpoint with a username and password or an API key, reads the token from the response (access_token, token, data.token, or a field you name), and saves only the token. The credentials themselves are never stored.

The Auth tab reads OpenAPI security declarations and supports Bearer and OAuth2 tokens, Basic authentication, and header, query, or cookie API keys. Django scans map AllowAny and IsUnauthenticated permissions to unauthenticated operations and map protected permission classes to a JWT Bearer scheme. When no security metadata is available, the Playground keeps a manual full Authorization header field. Global DRF DEFAULT_PERMISSION_CLASSES and ViewSet action overrides are considered; custom permissions use an explicit unknown-auth declaration instead of assuming JWT.

JSON request bodies are validated before sending and can be formatted in place. Operations with multiple supported request media types expose a content-type selector, including JSON-object editing for application/x-www-form-urlencoded requests. JSON, XML, plain text, CSV, YAML, and GraphQL can also be selected manually when the API supports a format that is not declared by its OpenAPI operation. JSON responses are formatted automatically and can be searched, and an HTML response is flagged when the operation documents JSON. Image responses are previewed and other binary responses can be saved as files. The response panel shows a color-coded status, duration, size, final URL, redirects, headers, and truncation state, and a JSON tree that expands on demand. Redirect following is optional, limited to five same-origin hops, and disabled by default. Requests run in the extension host, so the Playground is not subject to browser CORS; request and response bodies are limited to 2 MB, with oversized responses stopped while streaming, and requests time out after 30 seconds.

The Spec check tab compares each JSON response with the scanned OpenAPI document for that status code and lists type mismatches, missing required properties, undocumented properties, and unexpected enum values. Formats and numeric or length limits are not checked.

Sending to an origin that is neither the configured API, the OpenAPI server, nor a saved environment requires explicit session approval. In-flight requests can be cancelled. The History tab keeps the latest 50 requests for the workspace with open and send-again actions; auth values and other credential-like values (passwords, tokens, API keys, Authorization and Cookie headers) are removed before history is saved. Request logs in the APIScout Request Playground output channel redact API keys and credential-like query parameters.

Troubleshooting

Swagger Try it out reports Failed to fetch

Swagger Preview sends requests from the VS Code webview and therefore follows the browser's CORS rules. Confirm that apyguardApiScout.analyzedApiUrl points to the running API, then allow only the required VS Code development origin in the API's CORS configuration. Do not use an unrestricted allow-all CORS policy in production. If changing API CORS is not appropriate, use Request Playground instead; it sends requests through the extension host.

Python executable not found

This appears only when APIScout runs the engine with Python: from source, or with apyguardApiScout.enginePath set. Choose Find Interpreter when Doctor offers it, or set apyguardApiScout.pythonPath to a Python 3.9+ interpreter.

Engine not found

If you are running from source and the extension cannot resolve the engine automatically, set:

{
  "apyguardApiScout.enginePath": "/absolute/path/to/core-engine"
}

Empty scan results

Common causes:

  • the workspace is not a supported framework
  • routes are declared dynamically
  • the wrong folder is open

Run ApyGuard APIScout: Scan API Project first and inspect the raw inventory output before exporting.

  • Contact us
  • Jobs
  • Privacy
  • Manage cookies
  • Terms of use
  • Trademarks
  • Your Privacy Choices
  • Consumer Health Privacy
© 2026 Microsoft