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

# Get Started with Argus in 5 Minutes

> Install the Argus SDK, paste your DSN, and see your first error captured in the dashboard — all in under 5 minutes.

By the end of this guide you'll have Argus installed in your application, connected to your project via a DSN, and capturing real errors that appear live in your dashboard. The whole process takes about five minutes.

<Steps>
  <Step title="Create an account">
    Go to the [Argus dashboard](https://app.argus.dev) and sign up with your email, Google, or GitHub account.

    If you register with email, Argus sends a one-time passcode (OTP) to your inbox. Enter the code to verify your address and land on your new dashboard.
  </Step>

  <Step title="Create a project">
    From the **Projects Console**, click **New Project**. Give your project a name and select the platform that matches your application — **Browser**, **Node.js**, or **React**.

    After Argus creates the project, your **DSN** appears on screen. Copy it now — you'll paste it into your `init()` call in the next step.

    <Tip>
      Your DSN follows the format `https://PUBLIC_KEY@your-domain.com/PROJECT_ID`. The public key authenticates your SDK with the ingest endpoint; the project ID routes events to the right project. You can find your DSN again at any time under **Project Settings → DSN**.
    </Tip>
  </Step>

  <Step title="Install the SDK">
    Install the package that matches the platform you selected.

    **Browser**

    <CodeGroup>
      ```bash npm theme={null}
      npm install @argusdev/sdk-browser
      ```

      ```bash yarn theme={null}
      yarn add @argusdev/sdk-browser
      ```

      ```bash pnpm theme={null}
      pnpm add @argusdev/sdk-browser
      ```
    </CodeGroup>

    **Node.js**

    <CodeGroup>
      ```bash npm theme={null}
      npm install @argusdev/sdk-node
      ```

      ```bash yarn theme={null}
      yarn add @argusdev/sdk-node
      ```

      ```bash pnpm theme={null}
      pnpm add @argusdev/sdk-node
      ```
    </CodeGroup>

    **React**

    <CodeGroup>
      ```bash npm theme={null}
      npm install @argusdev/sdk-react
      ```

      ```bash yarn theme={null}
      yarn add @argusdev/sdk-react
      ```

      ```bash pnpm theme={null}
      pnpm add @argusdev/sdk-react
      ```
    </CodeGroup>
  </Step>

  <Step title="Initialize Argus">
    Call `init()` once, as early as possible in your application's entry point, with the DSN you copied in Step 2. From that point on, Argus automatically captures all uncaught exceptions and unhandled promise rejections — no additional code required.

    **Browser** — add this before any other application code in your entry file:

    ```ts theme={null}
    import { init } from '@argusdev/sdk-browser';

    init({
      dsn: 'https://PUBLIC_KEY@your-domain.com/PROJECT_ID',
      environment: 'production', // optional
      release: '1.0.0',          // optional — tie errors to a deploy
    });
    ```

    Argus hooks into `window.onerror` and `unhandledrejection`. It chains any handler you already have in place — nothing gets replaced.

    ***

    **Node.js** — initialize at the very top of your server entry file:

    ```ts theme={null}
    import { init, captureException, argusErrorHandler } from '@argusdev/sdk-node';

    init({
      dsn: 'https://PUBLIC_KEY@your-domain.com/PROJECT_ID',
      environment: 'production',
      release: '1.0.0',
    });

    // Express apps: mount after all routes, before your own error handler
    app.use(argusErrorHandler());
    ```

    Argus listens for `uncaughtException` (captures then exits with code `1`, preserving Node's expected crash behaviour) and `unhandledRejection` (captures without exiting).

    ***

    **React** — initialize once and wrap your component tree with `<ArgusErrorBoundary>`:

    ```tsx theme={null}
    import { init, ArgusErrorBoundary } from '@argusdev/sdk-react';

    init({
      dsn: 'https://PUBLIC_KEY@your-domain.com/PROJECT_ID',
      environment: 'production',
      release: '1.0.0',
    });

    export function App() {
      return (
        <ArgusErrorBoundary fallback={<p>Something went wrong.</p>}>
          <YourApp />
        </ArgusErrorBoundary>
      );
    }
    ```

    <Note>
      React render-cycle crashes don't reach `window.onerror` in production builds. `<ArgusErrorBoundary>` uses `componentDidCatch` — the only reliable hook for render errors — and attaches the crashing component name as a tag on the captured event.
    </Note>

    You can also capture errors manually anywhere in your code:

    ```ts theme={null}
    import { captureException } from '@argusdev/sdk-react'; // or sdk-browser / sdk-node

    try {
      riskyOperation();
    } catch (err) {
      captureException(err);
    }
    ```
  </Step>

  <Step title="Verify in the dashboard">
    Trigger an error in your application — throw an exception, reject a promise, or let a component crash — then open the Argus dashboard and navigate to **Issues**.

    Your first error should appear within a few seconds. Click into it to see the full stack trace, environment, release, and request context Argus captured automatically.

    <Tip>
      Not seeing your event? Double-check that you pasted the full DSN (including the `https://` prefix and the project ID path segment). Check your browser's Network tab or Node console for any `401` or `400` responses from the ingest endpoint.
    </Tip>
  </Step>
</Steps>

## Next Steps

Now that you're capturing errors, explore what Argus can do:

* **[Browser SDK reference](/sdks/browser)** — manual capture, `release` tagging, and cross-origin script handling
* **[Node.js SDK reference](/sdks/node)** — Express middleware, environment variables, and uncaught exception behaviour
* **[React SDK reference](/sdks/react)** — `<ArgusErrorBoundary>` props, nested boundaries, and fallback UI patterns
* **[Alert rules](/platform/alerts)** — get notified by email or webhook the moment a new issue opens