> ## Documentation Index
> Fetch the complete documentation index at: https://docs.scoutqa.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Scout CLI - Vibe Testing from Your Terminal

> Find bugs in your Lovable, Replit, V0, or Base44 app from the command line. AI-powered vibe testing for solo founders, vibe coders, and side project builders.

<head>
  <script type="application/ld+json">
    {JSON.stringify({
            "@context": "https://schema.org",
            "@type": "SoftwareApplication",
            "name": "Scout CLI",
            "applicationCategory": "WebApplication",
            "applicationSubCategory": "Testing Tool",
            "description": "AI-powered vibe testing CLI for finding bugs in Lovable, Replit, V0, Base44, and web applications. Built for solo founders and vibe coders.",
            "url": "https://docs.scoutqa.ai/tooling/cli",
            "operatingSystem": "macOS, Linux, Windows",
            "softwareRequirements": "Node.js",
            "installUrl": "https://www.npmjs.com/package/@scoutqa/cli",
            "creator": {
              "@type": "Organization",
              "name": "Scout",
              "url": "https://scoutqa.ai"
            },
            "keywords": "Lovable testing, Replit testing, V0 testing, Base44 testing, vibe testing, solo founder, side project, bug detection"
          })}
  </script>
</head>

The Scout CLI brings **vibe testing** directly to your terminal. Vibe testing is a new approach to QA where you describe what to test in natural language, and AI handles the rest - no test scripts required.

<Note>
  **What is Vibe Testing?** Vibe testing lets you test web applications by simply describing what you want tested. Instead of writing brittle test scripts, you tell Scout "test the login flow" or "check accessibility" and AI explores your app like a human tester would.
</Note>

## Installation

```bash theme={null}
npm install -g @scoutqa/cli
```

## Authentication

The CLI supports multiple authentication methods (in priority order):

### 1. Environment Variables (recommended for CI/CD)

```bash theme={null}
export SCOUT_API_KEY=sk-scout-xxx
export SCOUT_SERVER_URL=https://scoutqa.ai  # optional, this is the default
```

### 2. OAuth Login (for local development)

```bash theme={null}
scoutqa auth login
```

Opens your browser for authentication. Stores access and refresh tokens locally.

### 3. API Key

Set an API key manually:

```bash theme={null}
scoutqa auth set-api-key <your-api-key>
```

<Tip>
  **New in v0.11.0:** You can now create and manage API keys from the web UI at **Account Settings → API Keys**. No CLI required.
</Tip>

Check your authentication status:

```bash theme={null}
scoutqa auth status
```

### Unauthenticated Access

<Note>
  **New in v0.10.1:** The `create-execution` and `send-message` commands now support unauthenticated access for quick testing. This is ideal for trying Scout without signing up or for simple CI/CD pipelines.
</Note>

```bash theme={null}
# Run a test without authentication
scoutqa --url https://your-app.com --prompt "Test the homepage"
```

Unauthenticated executions have some limitations:

* Results are publicly accessible
* No project organization
* Limited execution history

For production use, we recommend authenticating to access full features.

## Commands

### Create a Test Execution

```bash theme={null}
# Test a specific URL with a prompt
scoutqa --url https://your-app.com --prompt "Test the login flow"

# Run accessibility audit
scoutqa --url https://your-app.com --prompt "Check accessibility compliance"

# Exploratory testing
scoutqa --url https://staging.your-app.com --prompt "Find usability issues in checkout"
```

<Note>
  `create-execution` is the default command and can be omitted.
</Note>

### List Executions

```bash theme={null}
scoutqa list-executions
```

### Continue an Execution

Send follow-up messages to an ongoing execution:

```bash theme={null}
scoutqa send-message --execution-id exec_123 --prompt "Now test the logout button"
```

### Issue Verification

<Note>
  **New in v0.11.0:** Verify bugs directly from the CLI — perfect for CI/CD pipelines and post-fix validation.
</Note>

List issues from a previous execution:

```bash theme={null}
scoutqa list-issues --execution-id <execution-id>
```

Verify whether a specific issue is still reproducible:

```bash theme={null}
scoutqa issue-verify --issue-id <issue-id>
```

This is especially useful in a fix-then-verify workflow:

1. Scout finds a bug → developer fixes it → run `issue-verify` to confirm the fix
2. CI/CD pipeline runs `list-issues` after a test, then `issue-verify` on any critical issues before merging

### Authentication Commands

| Command                                   | Description                              |
| ----------------------------------------- | ---------------------------------------- |
| `scoutqa auth status`                     | Show authentication status               |
| `scoutqa auth login`                      | Login via browser (OAuth)                |
| `scoutqa auth set-api-key <key>`          | Set API key manually                     |
| `scoutqa list-issues --execution-id <id>` | List issues from an execution            |
| `scoutqa issue-verify --issue-id <id>`    | Verify if an issue is still reproducible |
| `scoutqa auth logout`                     | Clear stored credentials                 |

## CI/CD Integration

Add Scout to your GitHub Actions workflow:

```yaml theme={null}
name: Scout QA
on: [push]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: '20'
      - run: npm install -g @scoutqa/cli
      - run: scoutqa --url ${{ env.STAGING_URL }} --prompt "Smoke test critical flows"
        env:
          SCOUT_API_KEY: ${{ secrets.SCOUT_API_KEY }}
```

## Troubleshooting

| Issue                 | Solution                                            |
| --------------------- | --------------------------------------------------- |
| Authentication failed | Run `scoutqa auth logout` then `scoutqa auth login` |
| Command not found     | Ensure npm global bin is in your PATH               |
| Tests timing out      | Check network connectivity to target URL            |

Check your auth status with `scoutqa auth status`.

## Use Cases for Vibe Testing

* **Smoke Testing** - Quick validation before deployments
* **Regression Testing** - Verify existing features still work after changes
* **Accessibility Testing** - WCAG compliance audits
* **Exploratory Testing** - Discover edge cases and unexpected behaviors
* **User Flow Validation** - Ensure critical paths like checkout and signup work

## Frequently Asked Questions

<AccordionGroup>
  <Accordion title="What is vibe testing?">
    Vibe testing is AI-powered exploratory testing where you describe tests in natural language instead of writing code. Scout's AI agent navigates your application, identifies issues, and reports findings - similar to how a human QA tester would explore your app.
  </Accordion>

  <Accordion title="How is vibe testing different from traditional automated testing?">
    Traditional automated testing requires writing and maintaining test scripts. Vibe testing uses AI to understand your intent from natural language and autonomously explores your application. This means faster test creation, less maintenance, and better coverage of edge cases.
  </Accordion>

  <Accordion title="Can I use Scout CLI in CI/CD pipelines?">
    Yes! Scout CLI integrates with GitHub Actions, CircleCI, Jenkins, and any CI/CD system. Use it to gate deployments with quality checks.
  </Accordion>

  <Accordion title="What types of applications can I test?">
    Scout CLI works with any web application accessible via a publicly accessible URL - SPAs, server-rendered apps, staging environments, and production sites. For localhost testing, you'll need to use a tunneling service like [ngrok](https://ngrok.com/our-product/secure-tunnels) to expose your local server.
  </Accordion>
</AccordionGroup>

## What's Next

* See [Claude Code Skill](/tooling/claude-code-skill) to use Scout directly in Claude Code
* See [Kiro Power](/tooling/kiro-power) to integrate Scout into Kiro IDE

Questions? Reach out at [huy.tieu@scoutqa.ai](mailto:huy.tieu@scoutqa.ai).

***

<AccordionGroup>
  <Accordion title="Testing localhost applications">
    Scout requires a **publicly accessible URL** to run tests. Deployed environments like staging and production work immediately.

    For localhost testing, use a tunneling service like [ngrok](https://ngrok.com/our-product/secure-tunnels):

    ```bash theme={null}
    # Start your app
    npm run dev

    # In another terminal, create a tunnel
    ngrok http 3000

    # Use the tunnel URL with Scout
    scoutqa --url https://abc123.ngrok.io --prompt "Test the login flow"
    ```

    \*Third-party tunneling services are not affiliated with Scout. Use at your own risk.
  </Accordion>
</AccordionGroup>
