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

# Integrations & Data Overview

> How data flows into Causeloop — connectors, direct ingestion, and webhooks — and becomes issues, patterns, and predictions.

Causeloop needs signal from your systems to find the patterns behind recurring failures. There are three ways to bring that signal in, and one way to push results back out.

## How data becomes insight

Every piece of data Causeloop receives goes through the same pipeline:

<Steps>
  <Step title="Raw signal arrives">
    A connector polls your external tool on a schedule, or your system pushes a record to the ingestion API, or an inbound webhook delivers an event.
  </Step>

  <Step title="Normalization & deduplication">
    Records are validated, normalized to a canonical shape (title, severity, source, timestamp), and deduplicated by `external_id` + `source`.
  </Step>

  <Step title="Issue created or updated">
    Each unique signal becomes an **Issue** — the atomic unit of work in Causeloop.
  </Step>

  <Step title="Pattern clustering">
    Issues with similar root causes are clustered into **Patterns**. Causeloop surfaces which pattern a new issue belongs to in real time.
  </Step>

  <Step title="Prediction & recommendation">
    Causeloop predicts which open issues will recur and surfaces recommendations for the fix most likely to hold.
  </Step>
</Steps>

## Three ways to bring data in

<CardGroup cols={3}>
  <Card title="Connectors" icon="plug" href="/integrations/connector-catalog">
    Managed integrations with external tools — Jira, PagerDuty, GitHub, ServiceNow, Datadog, and more. Causeloop polls on your schedule, handles OAuth, and backfills historical data. Best for tools you already use.
  </Card>

  <Card title="Ingestion API" icon="arrow-up-to-line" href="/integrations/data-ingestion">
    Push records directly from any system using `POST /ingest/events` (single event) or `POST /ingest/batch` (up to 500 at once). Use this for home-grown tools, scripts, or pipelines that don't have a managed connector.
  </Card>

  <Card title="Inbound Webhooks" icon="webhook" href="/integrations/webhooks">
    Register a connector as a webhook target so third-party tools can push events to Causeloop in real time. Every payload is HMAC-SHA256 verified and the endpoint fails closed — a missing or invalid signature is always a 401.
  </Card>
</CardGroup>

## One way to push results out

**Outbound webhooks** let Causeloop notify your systems when something significant happens — a sync succeeds or fails, an issue is ingested, a pattern is detected. Register an HTTPS endpoint via `POST /webhooks`, choose your event types, and Causeloop signs every delivery with your secret.

See [Webhooks](/integrations/webhooks) for the full inbound and outbound reference.

## Monitoring your sources

Once data is flowing, **Sources** gives you a per-source view of real ingest volume — every place findings actually arrive from, whether a configured connector or an ad-hoc ingestion channel (e.g. `custom_api` for direct API/file ingest with no connector configured).

`GET /v1/sources` returns one card per source: issue count over a rolling 30-day window, last-ingested timestamp, and a 14-day daily sparkline. `GET /v1/sources/summary` returns workspace-wide KPIs — `events_per_day`, `active_sources` / `total_sources`, and `last_ingested_at` — over a configurable window (`window_days`, default 7).

<Note>
  Every figure on the Sources page is computed from stored issue data. A source with no activity in the window shows a zero-filled sparkline, not a synthetic one; metrics that cannot be derived from stored data (like historical parse latency) are simply absent from the response rather than estimated.
</Note>

## Where to manage integrations

Admins manage all integrations in the Causeloop UI at **Settings → Integrations** (`https://app.causeloop.ai/integrations`). From there you can:

* Browse the connector catalog and connect a new source
* View sync history and health for each connector
* Register and manage outbound webhook endpoints
* Rotate signing secrets

Developers who prefer to manage integrations programmatically can use the Connectors API. All routes require a Bearer token — see [Authentication](/api-reference/authentication) for details.

## API quick-reference

| Resource                  | Base path                                    | Required scope                         |
| ------------------------- | -------------------------------------------- | -------------------------------------- |
| Connector catalog         | `GET /v1/connector-catalog`                  | `connectors:read`                      |
| Connectors (CRUD)         | `/v1/connectors`                             | `connectors:read` / `connectors:admin` |
| Connector sync / backfill | `POST /v1/connectors/{id}/sync`              | `connectors:admin`                     |
| OAuth flow                | `/v1/connectors/{id}/oauth/start`            | `connectors:admin`                     |
| Ingest (single)           | `POST /v1/ingest/events`                     | `ingest:write`                         |
| Ingest (batch)            | `POST /v1/ingest/batch`                      | `ingest:write`                         |
| Sources                   | `GET /v1/sources`, `GET /v1/sources/summary` | `connectors:read`                      |
| Webhooks (outbound)       | `/v1/webhooks`                               | `webhooks:read` / `webhooks:admin`     |
| Inbound webhook receiver  | `POST /v1/webhooks/inbound/{connector_id}`   | HMAC signature (no Bearer)             |
| Integrations health       | `GET /v1/integrations/health`                | `connectors:read`                      |

<Note>
  All API requests are scoped to your workspace. Include your API key as `Authorization: Bearer <token>`. See [API Reference](/api-reference/overview) for full endpoint documentation.
</Note>