Connector Reference

KaireonAI ships 85 connector types in the connector registry. 57 are production-ready; 28 are marked status: "coming_soon" and are gated behind a shared stub that returns a clear “vendor account required” response at runtime. Every entry below traces to a real registry row by line number.

What it does

Each registry entry is consumed by three layers:

Dynamic UI form — Data → Connectors → New reads connectionFields[] and authFields[<authMethod>][] from the connector registry and renders text / password / textarea / select / number inputs without any per-connector UI code.
Test Connection + send + pull — the connector executor for the chosen type exposes testConnection, optional send, and optional pull methods that talk to the vendor API. Ready connectors implement the methods directly; coming-soon connectors return { ok: false, status: 503, error: "coming_soon:<type>: vendor account required..." } from the shared stub.
Pipeline runner — Flow IR source/target nodes resolve to the same executor through the connector dispatcher. The envelope is always { ok, status, latencyMs, body?, error? }.

Quick start

Pick a connector by type from the tables below, then create it via the API:

curl -X POST https://playground.kaireonai.com/api/v1/connectors \
  -H "Content-Type: application/json" \
  -H "X-API-Key: krn_your_key" \
  -d '{
    "name": "Customer Data Lake",
    "type": "aws_s3",
    "config": { "bucket": "my-data-lake", "prefix": "customers/", "region": "us-east-1" },
    "authMethod": "iam_role",
    "authConfig": { "roleArn": "arn:aws:iam::123456789012:role/KaireonDataAccess" }
  }'

Then test it:

curl -X POST https://playground.kaireonai.com/api/v1/connectors/test \
  -H "Content-Type: application/json" \
  -H "X-API-Key: krn_your_key" \
  -d '{ "id": "<connector-id>" }'

The Test Connection result is stored in Connector.lastTestedAt + Connector.lastError and surfaces in the UI as a green/red dot next to the connector row.

Status snapshot

Status	Count	Source
Total registered	80	`connectorRegistry.length` (`connector-registry.ts:100-1136`)
Ready (executor implemented)	52	Entries with no `status` field
Coming-soon (stub returns 503)	28	`kinesis` + `braze` + 26 W16 round-3 entries — all listed in the COMING_SOON_CONNECTORS set at `connector-registry.ts:36-50`

Per category:

Category	Total	Ready	Coming-soon
Object Storage	4	4	0
Streaming	3	2	1
Data Warehouses	8	8	0
Databases	3	3	0
CRM	11	6	5
Customer Data Platforms (CDP)	16	9	7
Messaging	12	7	5
APIs and Webhooks	23	13	10

Object Storage

All four object-store connectors share the same object-store abstraction shipped in Phase 6.2 and read CSV / JSON / JSON Lines / Parquet / Avro / ORC / TSV / XML through the same format-parser layer.

Amazon S3 (`aws_s3`)

Status: Ready
Auth: iam_role (env: roleArn, optional externalId) or access_key (env: accessKeyId, secretAccessKey, optional sessionToken)
Config fields: bucket, prefix, region (30 region options), endpoint (for MinIO and other S3-compatible stores)
File formats: Yes; default parquet
Use: File-based ingestion from S3 buckets. Supports CSV, JSON, Parquet, Avro, ORC, TSV, XML. (connector-registry.ts:103-150)

Google Cloud Storage (`gcs`)

Status: Ready
Auth: service_account_json (env: serviceAccountJson — paste the GCP service-account key JSON)
Config fields: bucket, prefix, projectId
File formats: Yes; default parquet
Use: File-based ingestion from GCS buckets. (connector-registry.ts:151-166)

Azure Blob Storage (`azure_blob`)

Status: Ready
Auth: connection_string (env: connectionString) or access_key (env: accountKey)
Config fields: accountName, containerName, prefix
File formats: Yes; default parquet
Use: File-based ingestion from Azure Blob containers. (connector-registry.ts:167-184)

SFTP (`sftp`)

Status: Ready
Auth: username_password (env: username, password) or ssh_key (env: username, privateKey, optional passphrase)
Config fields: host, port (default 22), remotePath
File formats: Yes; default csv
Use: Pull files from a remote SFTP server. (connector-registry.ts:185-200)

Streaming

Apache Kafka (`kafka`)

Status: Ready (batch polling — see Honest limits)
Auth: username_password (with saslMechanism — PLAIN, SCRAM-SHA-256, SCRAM-SHA-512) or api_key
Config fields: bootstrapServers, topic, consumerGroup, securityProtocol (PLAINTEXT / SASL_SSL / SASL_PLAINTEXT / SSL), schemaRegistryUrl
Use: Poll up to maxMessages records per pipeline run with a 15s wait window, commit offsets, close. True long-lived streaming requires execMode: "streaming" plus a worker deployment (gated by FLOW_STREAMING_ENABLED). (connector-registry.ts:203-228)

Confluent Cloud (`confluent_kafka`)

Status: Ready (batch polling)
Auth: api_key (env: apiKey, apiSecret — cluster keys; plus optional Schema Registry schemaRegistryApiKey + schemaRegistryApiSecret)
Config fields: bootstrapServers, topic, schemaRegistryUrl
Use: Same batch-polling semantics as kafka, with managed Confluent Cloud Schema Registry support. (connector-registry.ts:229-247)

Amazon Kinesis (`amazon_kinesis`)

Status: Coming-soon
Auth: iam_role (env: roleArn, optional externalId) or access_key (env: accessKeyId, secretAccessKey, optional sessionToken)
Config fields: streamName, region (us-east-1, us-west-2, eu-west-1), startPosition (LATEST or TRIM_HORIZON)
Use: Stream consumer for Kinesis Data Streams. Form definition + Test Connection ship today; live ingestion arrives when the operator wires SigV4 signing. (connector-registry.ts:248-269)

Data Warehouses

Snowflake (`snowflake`)

Status: Ready
Auth: username_password (env: username, password) or token (env: token, authenticator — snowflake / externalbrowser / oauth)
Config fields: account, warehouse, database, schema, role, sourceTable, rowLimit (default 100,000 — set 0 to remove the cap)
Use: SELECT * FROM <sourceTable> LIMIT <rowLimit> against the warehouse. (connector-registry.ts:272-296)

Databricks (`databricks`)

Status: Ready
Auth: token (env: token) or oauth2 (env: clientId, clientSecret, tokenUrl, refreshToken)
Config fields: host (workspace URL), httpPath, catalog, schema
Use: SQL Statement Execution API v2 — submit a query against a SQL warehouse and read result.data_array. Requires warehouseId for SQL pulls. (connector-registry.ts:297-311, executor at lib/connector-executors/reverse-etl.ts)

Google BigQuery (`bigquery`)

Status: Ready
Auth: service_account_json (env: serviceAccountJson)
Config fields: projectId, dataset, location (US, EU, us-central1, europe-west2), sourceTable, rowLimit (default 100,000)
Use: SELECT * FROM <dataset>.<sourceTable> LIMIT <rowLimit> against BigQuery. (connector-registry.ts:312-332)

Amazon Redshift (`redshift`)

Status: Ready
Auth: username_password (env: username, password) or iam_role (env: roleArn, optional externalId)
Config fields: host (cluster endpoint), port (default 5439), database, schema
Use: Connect to Redshift clusters or serverless endpoints. (connector-registry.ts:333-347)

Snowpipe (`snowpipe`)

Status: Ready
Auth: token (env: jwt — keypair-signed JWT generated via snowsql --generate-jwt)
Config fields: account (e.g. abc12345.us-east-2.aws), pipeName (e.g. DB.SCHEMA.PIPE_NAME)
Use: POST staged files to /v1/data/pipes/<pipe>/insertFiles with X-Snowflake-Authorization-Token-Type: KEYPAIR_JWT. Send-side only (destination connector). (connector-registry.ts:747-762, executor at lib/connector-executors/reverse-etl.ts)

Fivetran (`fivetran`)

Status: Ready
Auth: api_key (env: apiKey, apiSecret — used as Basic auth)
Config fields: none
Use: pull lists /v1/connectors; send triggers /v1/connectors/<connectorId>/sync (the connector ID comes from the event payload). (connector-registry.ts:763-778)

Hightouch (`hightouch`)

Status: Ready
Auth: api_key (env: apiKey — workspace API key, used as Bearer token)
Config fields: none
Use: send triggers /api/v1/syncs/<syncId>/trigger with optional fullResync. The syncId comes from the event payload. (connector-registry.ts:779-791)

Census (`census`)

Status: Ready
Auth: api_key (env: apiKey)
Config fields: none
Use: send triggers /api/v1/syncs/<syncId>/trigger against app.getcensus.com. (connector-registry.ts:792-804)

Databases

PostgreSQL (`postgresql`)

Status: Ready
Auth: username_password (env: username, password) or connection_string (env: connectionString)
Config fields: host, port (default 5432), database, schema, sslMode (prefer / require / verify-ca / verify-full / disable)
Use: Read from PostgreSQL tables; logical replication CDC is supported when the source role has the REPLICATION Postgres role attribute. (connector-registry.ts:350-371)

MySQL (`mysql`)

Status: Ready
Auth: username_password (env: username, password) or connection_string (env: connectionString)
Config fields: host, port (default 3306), database, sslMode (preferred / required / disabled)
Use: Read from MySQL or MariaDB databases. (connector-registry.ts:372-390)

MongoDB (`mongodb`)

Status: Ready
Auth: connection_string (env: connectionString — mongodb+srv://…) or username_password (env: host, port 27017, username, password)
Config fields: database, collection
Use: Read from MongoDB Atlas or self-hosted MongoDB. (connector-registry.ts:391-409)

CRM

Salesforce (`salesforce`)

Status: Ready
Auth: oauth2 (env: clientId, clientSecret, tokenUrl, refreshToken) or username_password (env: username, password, securityToken)
Config fields: instanceUrl, apiVersion (e.g. v58.0), objects (comma-separated list — Contact, Account, Opportunity, etc.)
Use: Sync CRM data from Salesforce sObjects. (connector-registry.ts:412-428)

HubSpot (`hubspot`)

Status: Ready
Auth: token (env: token — Private App Token) or oauth2 (env: clientId, clientSecret, tokenUrl, refreshToken)
Config fields: portalId, objects (e.g. contacts,companies,deals)
Use: Sync marketing, sales, and service data from HubSpot CRM. (connector-registry.ts:429-443)

Intercom (`intercom`)

Status: Ready
Auth: token (env: accessToken — from Developer Hub > your app > Authentication)
Config fields: region (us / eu / au)
Use: send with action: "track" posts to /events; default action upserts a contact via /contacts. (connector-registry.ts:622-636, executor at lib/connector-executors/cdp.ts)

Zendesk (`zendesk`)

Status: Ready
Auth: api_key (env: apiToken; the executor builds Basic auth as Basic base64(<email>/token:<apiToken>))
Config fields: subdomain, email
Use: testConnection GETs /api/v2/users/me.json; send creates Zendesk Support tickets and syncs users. (connector-registry.ts:637-652, executor at lib/connector-executors/cdp.ts)

HubSpot Marketing (`hubspot_marketing`)

Status: Ready
Auth: token (env: privateAppToken)
Config fields: none
Use: POST /events/v3/send with eventName, email, occurredAt, properties. Test pings /account-info/v3/details. (connector-registry.ts:846-851, executor at lib/connector-executors/mktauto.ts)

ActiveCampaign (`activecampaign`)

Status: Ready
Auth: api_key (env: apiKey — also requires eventKey in connection config)
Config fields: baseUrl (e.g. https://acme.api-us1.com), actid, eventKey
Use: Send events into ActiveCampaign Deep Data event-tracking. (connector-registry.ts:852-862)

Pardot (Salesforce MAP) (`pardot`)

Status: Coming-soon
Auth: oauth2 (env: clientId, clientSecret)
Config fields: businessUnitId
Use: Pull leads + score events from Pardot (Salesforce Marketing Cloud Account Engagement). Stub returns 503 coming_soon:pardot:…. (connector-registry.ts:918-925)

Marketo Engage (`marketo_engage`)

Status: Coming-soon
Auth: oauth2 (env: clientId, clientSecret)
Config fields: munchkinId
Use: Adobe Marketo Engage REST API — leads, programs, smart lists. (connector-registry.ts:926-933)

Salesforce Marketing Cloud (`salesforce_marketing_cloud`)

Status: Coming-soon
Auth: oauth2 (env: clientId, clientSecret)
Config fields: subdomain (tenant subdomain, e.g. mc6abc-def-ghi)
Use: SFMC REST API — Data Extensions, Journeys, contact updates. (connector-registry.ts:934-941)

Freshsales (`freshsales`)

Status: Coming-soon
Auth: api_key (env: apiKey)
Config fields: domain
Use: Freshsales CRM API. (connector-registry.ts:1086-1093)

Pipedrive (`pipedrive`)

Status: Coming-soon
Auth: api_key (env: apiToken)
Config fields: companyDomain
Use: Pipedrive deals + people API. (connector-registry.ts:1094-1101)

Customer Data Platforms (CDP)

Segment (`segment`)

Status: Ready
Auth: api_key (env: apiKey, apiSecret)
Config fields: workspaceSlug, sourceId
Use: Sync user profiles, events, and audiences. Supports track / identify / group payloads via Base64 Basic auth. (connector-registry.ts:444-456)

Iterable (`iterable`)

Status: Ready
Auth: api_key (env: apiKey — server-side key)
Config fields: dataCenter (us / eu)
Use: Send events and profile updates via /api/events/track with the Api-Key header. (connector-registry.ts:653-667)

Klaviyo (`klaviyo`)

Status: Ready
Auth: api_key (env: privateKey)
Config fields: publicKey (optional — Klaviyo.js identity)
Use: Send profile + event data to /api/events/ using the JSON:API envelope, revision 2024-10-15. (connector-registry.ts:668-682)

Amplitude (`amplitude`)

Status: Ready
Auth: api_key (env: apiKey)
Config fields: none
Use: POST events to https://api2.amplitude.com/2/httpapi with event_type, user_id, event_properties, time. (connector-registry.ts:807-812, executor at lib/connector-executors/analytics.ts)

Mixpanel (`mixpanel`)

Status: Ready
Auth: api_key (env: projectToken)
Config fields: none
Use: Base64-encode the event payload and GET https://api.mixpanel.com/track?data=…. (connector-registry.ts:813-818, executor at lib/connector-executors/analytics.ts)

PostHog (`posthog`)

Status: Ready
Auth: api_key (env: apiKey — Project API Key)
Config fields: host (defaults to https://app.posthog.com — point at a self-hosted instance if needed)
Use: POST /capture/ with event, distinct_id, properties. Test Connection GETs /decide/?token=…. (connector-registry.ts:819-825)

Customer.io (`customer_io`)

Status: Ready
Auth: api_key (env: siteId, apiKey — used as Basic auth)
Config fields: none
Use: POST /api/v1/customers/<userId>/events with name + data. (connector-registry.ts:826-831, executor at lib/connector-executors/mktauto.ts)

MoEngage (`moengage`)

Status: Ready
Auth: api_key (env: apiKey)
Config fields: appId, dataCenter (DC-01 through DC-05)
Use: POST https://api-0<dc>.moengage.com/v1/event/<appId> with the customer-id + actions array. Basic auth uses appId:apiKey. (connector-registry.ts:832-838)

CleverTap (`clevertap`)

Status: Ready
Auth: api_key (env: passcode)
Config fields: accountId
Use: POST https://api.clevertap.com/1/upload with X-CleverTap-Account-Id and X-CleverTap-Passcode headers; events use evtName + evtData. (connector-registry.ts:839-845)

Segment Personas (`segment_personas`)

Status: Coming-soon
Auth: api_key (env: personasApiKey)
Config fields: spaceId
Use: Twilio Segment audiences + traits sync. (connector-registry.ts:952-959)

mParticle (`mparticle`)

Status: Coming-soon
Auth: api_key (env: apiKey, apiSecret)
Config fields: podUrl (Pod base URL)
Use: mParticle Audience API + Events API. (connector-registry.ts:960-967)

Tealium AudienceStream (`tealium`)

Status: Coming-soon
Auth: api_key (env: apiKey)
Config fields: account, profile
Use: Tealium AudienceStream + EventStream sync. (connector-registry.ts:968-975)

Hightouch (Reverse ETL) (`hightouch_reverse_etl`)

Status: Coming-soon
Auth: api_key (env: apiKey)
Config fields: workspaceId
Use: Hightouch reverse-ETL — warehouse models → SaaS destinations. Distinct from hightouch (which is the trigger-syncs API). (connector-registry.ts:976-983)

Census (Reverse ETL) (`census_reverse_etl`)

Status: Coming-soon
Auth: api_key (env: apiKey)
Config fields: workspaceId
Use: Getcensus reverse-ETL warehouse → SaaS sync. Distinct from census. (connector-registry.ts:984-991)

Adobe Experience Platform (`adobe_experience_platform`)

Status: Coming-soon
Auth: oauth2 (env: clientId, clientSecret)
Config fields: imsOrg, sandbox
Use: Adobe Experience Platform — XDM datasets + audiences. (connector-registry.ts:992-999)

Klaviyo Profiles (`klaviyo_profile`)

Status: Coming-soon
Auth: api_key (env: privateApiKey)
Config fields: none
Use: Klaviyo Profiles + Lists API — separate from the existing Klaviyo events connector. (connector-registry.ts:1052-1059)

Messaging

Slack (`slack`)

Status: Ready
Auth: none — uses an Incoming Webhook URL
Config fields: webhookUrl (must match ^https://hooks.slack.com/), defaultChannel
Use: POST a JSON payload to the webhook. Default body shape is { text } or { blocks }. Test ping sends text: "KaireonAI connection test (ignore)". (connector-registry.ts:581-593, executor at lib/connector-executors/messaging.ts)

Microsoft Teams (`microsoft_teams`)

Status: Ready
Auth: none — uses an Incoming Webhook URL
Config fields: webhookUrl (must match ^https://.*\.webhook\.office\.com/)
Use: POST a MessageCard schema (@type: "MessageCard", @context: "https://schema.org/extensions", summary, text). If payload.event.card is set the executor passes it through unchanged. (connector-registry.ts:594-605, executor at lib/connector-executors/messaging.ts:43-72)

WhatsApp Business (`whatsapp_business`)

Status: Ready
Auth: token (env: accessToken — Meta system-user access token)
Config fields: phoneNumberId, businessAccountId
Use: POST https://graph.facebook.com/v20.0/<phoneNumberId>/messages with messaging_product: "whatsapp", to, type, plus text or template. Test GETs /<phoneNumberId>?fields=id. (connector-registry.ts:606-621, executor at lib/connector-executors/messaging.ts:78-113)

Twilio SMS (`twilio_sms`)

Status: Ready
Auth: api_key (env: accountSid, authToken — used as HTTP Basic auth)
Config fields: fromNumber (E.164 — +15551234567)
Use: Form-encoded POST to /Messages.json against the Twilio Programmable Messaging API. (connector-registry.ts:683-700)

SendGrid (`sendgrid`)

Status: Ready
Auth: api_key (env: apiKey — Full Access)
Config fields: defaultFrom
Use: POST /v3/mail/send with the SendGrid personalizations schema, Bearer auth. (connector-registry.ts:701-715)

Postmark (`postmark`)

Status: Ready
Auth: api_key (env: serverToken)
Config fields: defaultFrom, messageStream (default outbound)
Use: POST /email with X-Postmark-Server-Token header on a configurable message stream. (connector-registry.ts:716-731)

PagerDuty (`pagerduty`)

Status: Ready
Auth: api_key (env: routingKey — Service > Integrations > Events API v2)
Config fields: defaultSeverity (info / warning / error / critical)
Use: POST /enqueue (Events API v2) with optional dedup_key derived from the request idempotency key. (connector-registry.ts:732-746)

OneSignal (`onesignal`)

Status: Coming-soon
Auth: api_key (env: restApiKey)
Config fields: appId
Use: Push notifications + email/SMS through the OneSignal REST API. (connector-registry.ts:944-951)

Drift (`drift`)

Status: Coming-soon
Auth: api_key (env: apiToken)
Config fields: none
Use: Drift conversations + Playbooks API. (connector-registry.ts:1060-1067)

Front (`front`)

Status: Coming-soon
Auth: api_key (env: apiToken)
Config fields: none
Use: Front shared inbox API. (connector-registry.ts:1068-1075)

Freshdesk (`freshdesk`)

Status: Coming-soon
Auth: api_key (env: apiKey)
Config fields: domain (e.g. acme.freshdesk.com)
Use: Freshdesk tickets + contacts API. (connector-registry.ts:1078-1085)

Braze (`braze`)

Status: Coming-soon
Auth: api_key (env: apiKey, apiSecret)
Config fields: restEndpoint (US-01, US-02, US-03, EU-01)
Use: Sync campaign performance and user-engagement data from Braze. The current braze registry entry resolves through the shared coming-soon.ts stub; an earlier release-notes claim of a live /users/track batch executor is superseded. (connector-registry.ts:457-474)

APIs and Webhooks

Webhook (`webhook`)

Status: Ready
Auth: api_key (env: apiKey — clients must send X-API-Key) or token (env: token — Bearer)
Config fields: path (e.g. /ingest/my-webhook), maxBatchSize
Use: Receive data via inbound webhooks. KaireonAI provides a unique endpoint URL keyed off path. (connector-registry.ts:477-493)

REST API (`rest_api`)

Status: Ready
Auth: api_key, oauth2, token, or username_password
Config fields: baseUrl, method (GET / POST), paginationType (none / offset / cursor / link), headers (JSON map for custom headers)
Use: Pull data from any REST API with configurable polling and pagination. SSRF-guarded by validateAndResolve. (connector-registry.ts:494-515)

CSV File Upload (`csv_upload`)

Status: Ready
Auth: none
Config fields: delimiter (comma / tab / semicolon), hasHeader (true / false)
Use: Upload CSV files directly through the UI. The fastest connector for getting started — no external service to wire. (connector-registry.ts:518-537)

Shopify (`shopify`)

Status: Ready
Auth: token (env: token — Admin API Access Token from Shopify Admin > Settings > Apps and sales channels > Develop apps)
Config fields: shopDomain (e.g. my-store.myshopify.com)
Use: Pull from /orders.json against the Shopify Admin REST API with updated_at_min pagination. (connector-registry.ts:538-551)

Stripe (`stripe`)

Status: Ready
Auth: api_key (env: apiKey — Secret Key starting sk_live_ or sk_test_)
Config fields: none
Use: Pull /v1/charges with created[gte] filter. Sync payments, customers, subscriptions, and invoices. (connector-registry.ts:552-563)

Mailchimp (`mailchimp`)

Status: Ready
Auth: api_key (env: apiKey — format key-dcN)
Config fields: serverPrefix (e.g. us19), listId
Use: Pull /lists/<listId>/members?since_last_changed=… from the data-center-aware endpoint. (connector-registry.ts:564-578)

Zapier (`zapier`)

Status: Ready
Auth: none — uses an Incoming Webhook URL
Config fields: webhookUrl (must match ^https://hooks.zapier.com/)
Use: Trigger a Zapier workflow via webhook. POSTs the event payload as JSON. (connector-registry.ts:863-869, executor at lib/connector-executors/workflow-billing.ts:8-26)

n8n (`n8n`)

Status: Ready
Auth: token (env: authToken — optional Bearer)
Config fields: webhookUrl
Use: Trigger an n8n workflow via the webhook node. POSTs the event payload as JSON; adds Authorization: Bearer <authToken> when set. (connector-registry.ts:870-876)

Adyen (`adyen`)

Status: Ready
Auth: api_key (env: apiKey — sent as X-API-Key)
Config fields: environment (test / live — selects https://checkout-test.adyen.com/v71 vs https://checkout-live.adyen.com/v71)
Use: Payment processing — POST /payments with the Checkout API v71 payment object from payload.event.payment. (connector-registry.ts:877-883)

Recurly (`recurly`)

Status: Ready
Auth: api_key (env: apiKey — used as Basic auth)
Config fields: none
Use: Pull /invoices?limit=…&updated_at[gte]=… against https://v3.recurly.com with Accept: application/vnd.recurly.v2021-02-25. (connector-registry.ts:884-889)

Zuora (`zuora`)

Status: Ready
Auth: token (env: bearerToken — OAuth Bearer)
Config fields: host (e.g. https://rest.zuora.com)
Use: Pull /v1/subscriptions for catalog, subscriptions, usage. Test pings /v1/catalog/products?pageSize=1. (connector-registry.ts:890-896)

Chargebee (`chargebee`)

Status: Ready
Auth: api_key (env: apiKey — Full-Access; used as Basic auth)
Config fields: site (e.g. acme for acme.chargebee.com)
Use: Pull /api/v2/subscriptions?limit=… for subscriptions and customers. (connector-registry.ts:897-903)

Typeform (`typeform`)

Status: Ready
Auth: token (env: apiToken — Personal Access Token, used as Bearer)
Config fields: formId
Use: Pull /forms/<formId>/responses?page_size=…&since=… for form responses. Test pings /me. (connector-registry.ts:904-910)

Google Customer Match (`google_customer_match`)

Status: Coming-soon
Auth: oauth2 (env: clientId, clientSecret, refreshToken)
Config fields: customerId
Use: Push hashed customer lists to Google Ads Customer Match. (connector-registry.ts:1002-1009)

TikTok Ads (`tiktok_ads`)

Status: Coming-soon
Auth: oauth2 (env: accessToken)
Config fields: advertiserId
Use: TikTok Ads Custom Audiences sync. (connector-registry.ts:1010-1017)

LinkedIn Audiences (`linkedin_audiences`)

Status: Coming-soon
Auth: oauth2 (env: clientId, clientSecret)
Config fields: accountId
Use: LinkedIn Matched Audiences sync. (connector-registry.ts:1018-1025)

Pinterest Ads (`pinterest_ads`)

Status: Coming-soon
Auth: oauth2 (env: accessToken)
Config fields: adAccountId
Use: Pinterest Audience API. (connector-registry.ts:1026-1033)

Snapchat Ads (`snapchat_ads`)

Status: Coming-soon
Auth: oauth2 (env: accessToken)
Config fields: adAccountId
Use: Snapchat Audience Match API. (connector-registry.ts:1034-1041)

Meta Conversions API (`meta_conversions_api`)

Status: Coming-soon
Auth: api_key (env: accessToken)
Config fields: pixelId
Use: Meta CAPI server-side event forwarding. (connector-registry.ts:1042-1049)

Asana (`asana`)

Status: Coming-soon
Auth: oauth2 (env: accessToken — Personal Access Token)
Config fields: workspaceId
Use: Asana Tasks + Projects API. (connector-registry.ts:1104-1111)

Linear (`linear`)

Status: Coming-soon
Auth: api_key (env: apiKey)
Config fields: none
Use: Linear issues + cycles API. (connector-registry.ts:1112-1119)

Notion (`notion`)

Status: Coming-soon
Auth: oauth2 (env: integrationToken)
Config fields: workspaceId
Use: Notion databases + pages API. (connector-registry.ts:1120-1127)

Airtable (`airtable`)

Status: Coming-soon
Auth: api_key (env: personalAccessToken)
Config fields: baseId
Use: Airtable bases + tables API. (connector-registry.ts:1128-1135)

Reference

Executor interface

Every executor implements the platform’s connector-executor interface, shaped as follows:

interface ConnectorExecutor {
  readonly type: ConnectorType;
  testConnection(config: ConnectorConfig): Promise<ConnectorResponse>;
  send?(config: ConnectorConfig, payload: SendPayload): Promise<ConnectorResponse>;
  pull?(config: ConnectorConfig, opts?: PullOptions): Promise<ConnectorResponse<PulledRow[]>>;
}

Returned response envelope:

interface ConnectorResponse<T = unknown> {
  ok: boolean;
  status: number;
  latencyMs: number;
  body?: T;
  error?: string;
}

Timeouts are enforced with a per-call abort controller — the default is 10 seconds. Source pull connectors implement the pull method; destination connectors implement the send method. A connector that does both (e.g. fivetran, snowpipe) implements both.

Coming-soon stub contract

Every coming-soon connector resolves through a single shared stub. The testConnection, send, and pull methods all return:

{
  "ok": false,
  "status": 503,
  "error": "coming_soon:<type>: vendor account required. Configure <TYPE>_API_KEY (or vendor-specific equivalent) and replace the coming-soon stub with a real executor under platform/src/lib/connector-executors/."
}

The connector dispatcher registers a stub for every entry in the coming-soon set, so the executor lookup never returns nothing for a registered connector. Coming-soon connectors are visibly badged and disabled in the connector picker.

UI wiring

Every connector appears automatically in Data → Connectors because the picker reads connectorRegistry from connector-registry.ts. Each entry declares connectionFields + authFields for each supportedAuthMethods value; the dynamic form builder renders the right inputs (text / password / textarea / select / number) without per-connector UI code.

Auth method matrix

`authMethod`	Field keys consumed	Used by
`iam_role`	`roleArn`, `externalId`	`aws_s3`, `amazon_kinesis`, `redshift`
`access_key`	`accessKeyId`, `secretAccessKey`, `sessionToken` (or `accountKey` for Azure)	`aws_s3`, `amazon_kinesis`, `azure_blob`
`service_account_json`	`serviceAccountJson`	`gcs`, `bigquery`
`connection_string`	`connectionString`	`azure_blob`, `postgresql`, `mysql`, `mongodb`
`oauth2`	`clientId`, `clientSecret`, `tokenUrl`, `refreshToken`	`salesforce`, `hubspot`, `databricks`, `rest_api`, plus 8 W16 round-3 entries
`api_key`	`apiKey`, `apiSecret`, plus vendor-specific keys (`projectToken`, `passcode`, `routingKey`, `serverToken`, `apiToken`, `restApiKey`, `personasApiKey`, `personalAccessToken`)	30+ ready connectors
`username_password`	`username`, `password` (plus `securityToken` for Salesforce, `saslMechanism` for Kafka)	`kafka`, `salesforce`, `postgresql`, `mysql`, `mongodb`, `snowflake`, `redshift`, `sftp`, `rest_api`
`ssh_key`	`username`, `privateKey`, `passphrase`	`sftp`
`token`	`token`, `accessToken`, `bearerToken`, `jwt`, `privateAppToken`, `apiToken`, `integrationToken` (vendor-specific)	`databricks`, `snowflake`, `hubspot`, `whatsapp_business`, `intercom`, `shopify`, `snowpipe`, `zuora`, `n8n`, `typeform`, `webhook`, `rest_api`, plus 4 W16 entries
`none`	(none)	`csv_upload`, `slack`, `microsoft_teams`, `zapier`

Configuration

Environment variables

The registry itself reads no env vars — the consumer of the connector metadata decides where the secrets come from. In production deployments, secrets typically arrive via:

Connector form — operator pastes the secret in the UI; it is encrypted at rest in Connector.authConfig (authConfig is never returned in API responses; the list endpoint excludes it from the select clause).
Coming-soon vendor secrets — when the operator wires a real executor for a coming-soon connector, the convention is <TYPE>_API_KEY (or vendor-specific equivalent), per the stub error message.

Status flag semantics

status?: ConnectorStatus;   // "ready" | "coming_soon"
// Defaults to "ready" when omitted (connector-registry.ts:30-32).

status: "coming_soon" means: the form definition exists, the connector type is registered, and the executor lookup returns the shared stub. The picker badges and disables the entry so users are not misled.

Honest limits

Per-connector pages do not exist. This page is the only canonical reference for any single connector. Operators looking for a step-by-step setup guide for one specific vendor should follow the connectionFields + authFields here, then verify with Test Connection.
Coming-soon stubs are loud, not silent. Every coming-soon testConnection/send/pull returns { ok: false, status: 503, error: "coming_soon:…" }. They never silently succeed and never silently return zero rows.
hightouch_reverse_etl and census_reverse_etl are distinct from hightouch and census. The latter (ready) trigger sync runs by ID; the former (coming-soon) treat the warehouse → SaaS reverse-ETL flow as a dedicated CDP integration. They share vendor names but live as separate registry entries.
klaviyo and klaviyo_profile are distinct. klaviyo (ready) sends events to /api/events/; klaviyo_profile (coming-soon) targets the Profiles + Lists API.
Kafka and Confluent are batch pollers. Each pipeline run opens a consumer, polls up to maxMessages records with the configured wait timeout, commits offsets, and closes. True long-lived streaming requires execMode: "streaming" plus a worker deployment gated by FLOW_STREAMING_ENABLED.
braze was previously listed as ready in earlier release notes; the current registry entry carries status: "coming_soon" and the executor resolves to the shared coming-soon stub. Treat the older claim as superseded.

Data Platform — connector category overview, schema model, pipeline transforms.
Connectors API — REST endpoints for create / update / delete / test.
YAML Connectors — define your own connector via YAML when no built-in fits.
Pipeline IR — wire a connector into a Flow IR pipeline.

Get Started

Tutorials

Decisioning

Studio

Data Pipelines

AI & ML

Operations & Reporting

Governance & Security

Integrations

Reference

Documentation Index

​What it does

​Quick start

​Status snapshot

​Object Storage

​Amazon S3 (aws_s3)

​Google Cloud Storage (gcs)

​Azure Blob Storage (azure_blob)

​SFTP (sftp)

​Streaming

​Apache Kafka (kafka)

​Confluent Cloud (confluent_kafka)

​Amazon Kinesis (amazon_kinesis)

​Data Warehouses

​Snowflake (snowflake)

​Databricks (databricks)

​Google BigQuery (bigquery)

​Amazon Redshift (redshift)

​Snowpipe (snowpipe)

​Fivetran (fivetran)

​Hightouch (hightouch)

​Census (census)

​Databases

​PostgreSQL (postgresql)

​MySQL (mysql)

​MongoDB (mongodb)

​CRM

​Salesforce (salesforce)

​HubSpot (hubspot)

​Intercom (intercom)

​Zendesk (zendesk)

​HubSpot Marketing (hubspot_marketing)

​ActiveCampaign (activecampaign)

​Pardot (Salesforce MAP) (pardot)

​Marketo Engage (marketo_engage)

​Salesforce Marketing Cloud (salesforce_marketing_cloud)

​Freshsales (freshsales)

​Pipedrive (pipedrive)

​Customer Data Platforms (CDP)

​Segment (segment)

​Iterable (iterable)

​Klaviyo (klaviyo)

​Amplitude (amplitude)

​Mixpanel (mixpanel)

​PostHog (posthog)

​Customer.io (customer_io)

​MoEngage (moengage)

​CleverTap (clevertap)

​Segment Personas (segment_personas)

​mParticle (mparticle)

​Tealium AudienceStream (tealium)

​Hightouch (Reverse ETL) (hightouch_reverse_etl)

​Census (Reverse ETL) (census_reverse_etl)

​Adobe Experience Platform (adobe_experience_platform)

​Klaviyo Profiles (klaviyo_profile)

​Messaging

​Slack (slack)

​Microsoft Teams (microsoft_teams)

​WhatsApp Business (whatsapp_business)

​Twilio SMS (twilio_sms)

​SendGrid (sendgrid)

​Postmark (postmark)

​PagerDuty (pagerduty)

​OneSignal (onesignal)

​Drift (drift)

​Front (front)

​Freshdesk (freshdesk)

​Braze (braze)

​APIs and Webhooks

​Webhook (webhook)