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

# Taps and streams

> A tap is one stream: a transport, a pagination style, a sync mode, and a record shape.

Every connector is made of **taps**. A tap is a single stream of records
from the source: Linear `issues`, GitHub `pull_requests`, Slack
`channels`. The Linear connector, for example, includes sixteen taps, from
`issues` and `projects` to `comments` and `workflow_states`.

Taps are the unit you control: each one can be enabled or disabled per
connector, and each one lands as its own set of tables in
[your data lake](/data).

The connector definition describes **how** Parable fetches that stream.
You inspect that on `connector.taps[]` of an instance. You do not set
transport, pagination, or sync mode; they are how that source API works.
[How ingestion walks a source](/connectors/ingestion) follows those fields
through a real Linear query and a GitHub parent-child fan-out.

A tap looks like this (fields omitted):

```json theme={null}
{
  "name": "issues",
  "enabledByDefault": true,
  "sync": {
    "mode": "incremental",
    "cursorField": "updatedAt"
  },
  "transportOptions": [
    {
      "priority": 1,
      "apiType": "graphql",
      "pagination": { "type": "cursor" }
    }
  ]
}
```

## Transport

Each tap has one or more **transport options**. An option is one way to
call the source:

| `apiType`  | Meaning                             |
| ---------- | ----------------------------------- |
| `rest`     | HTTP REST endpoint (`restConfig`).  |
| `graphql`  | GraphQL endpoint (`graphqlConfig`). |
| `database` | Direct database extract.            |
| `file`     | File or export extract.             |
| `custom`   | Connector-specific transport.       |

`priority` chooses among options: **1 is highest**. If the preferred API
is missing on your plan or edition, Parable can fall through to the next
option. GitHub list endpoints are typically `rest`; Linear list endpoints
are typically `graphql`.

## Pagination

Sources page results in different ways. The transport option's
`pagination.type` is how Parable walks pages until the stream is
exhausted:

| `type`         | What the source returns                                              |
| -------------- | -------------------------------------------------------------------- |
| `cursor`       | A next-page token in the body (Linear GraphQL `pageInfo.endCursor`). |
| `link_header`  | RFC 5988 `Link` headers (GitHub, GitLab).                            |
| `offset`       | Offset / limit (or skip / take).                                     |
| `page_number`  | A page index.                                                        |
| `session_page` | A session id plus an incrementing page (Mixpanel Engage-style).      |
| `none`         | One response is the full set.                                        |

You do not pick this. It is why a GitHub tap and a Linear tap can share
the same sync engine and still talk to two different paging contracts.

## Sync mode

`sync.mode` is how much is fetched each run:

| `mode`        | Behavior                                                                                                                                    |
| ------------- | ------------------------------------------------------------------------------------------------------------------------------------------- |
| `incremental` | Only records that changed since the last watermark. `cursorField` names the field on each record (for example `updatedAt` or `updated_at`). |
| `full`        | Every record, every run. Used when the source cannot filter by time.                                                                        |

Incremental sync is why connectors stay fast against rate-limited APIs
even for large workspaces. The first incremental run may still walk a
lookback window (`maxLookbackDays` when the source retains only recent
data).

How the watermark is sent to the source is `incrementalParams.filterType`:

| `filterType`     | How the time window is applied                               |
| ---------------- | ------------------------------------------------------------ |
| `simple`         | Query parameters such as `since` / `until`.                  |
| `query_template` | A search/query string with window placeholders (Gmail `q`).  |
| `body_filter`    | A field in the JSON body (Linear GraphQL `variables.since`). |

Some APIs use a create-poll-fetch job (`sync.asyncQuery`). You will see
that block on the tap when the source works that way.

## Record shape

`schema` on the platform tap is the shape of records the stream emits.
Incoming data is checked against it during ingestion, so malformed source
records are caught at the boundary instead of corrupting lake tables.
Flags on that schema (`x-transformDedupKey`, `x-transformOrdering`,
identity tags) are how the row lands uniquely in the
[providers](/data/providers) pool. See
[tap projection](/connectors/tap-projection).

Your workspace can narrow that shape with `outputSchema` on a
[workspace tap overlay](#managing-taps-via-the-api). For an override, the
overlay must stay a structural subset of the platform tap's schema.

`enabledByDefault` is the definition default. Your overlay's `enabled`
flag is what actually runs.

## Managing taps via the API

| Action                              | Endpoint                                                      |
| ----------------------------------- | ------------------------------------------------------------- |
| List workspace taps and their state | `GET /api/tenant-connector-taps/tenant-connector-taps`        |
| Enable a tap on a connector         | `POST /api/tenant-connector-taps/create-tenant-connector-tap` |
| Disable or reconfigure a tap        | `PATCH /api/tenant-connector-taps/{id}`                       |

`PATCH` can change `enabled`, `name`, `description`, `outputSchema`, and
`config`. It cannot change sync mode, pagination, or transport. Those stay
on the platform tap.

See the [API Reference](/api-reference/overview) for full request and
response shapes.