Connectors — Sync External Services Into Your Pod

Connectors bring data from external services into your Synap pod. Google Calendar events, GitHub issues, contacts — all synced as regular entities that you can search, view, link, and organize alongside everything else.

How connectors work

Synap uses a pull-sync model powered by Nango, a self-hosted OAuth and sync platform. The flow works like this: you authorize a connection (Google, GitHub, etc.) through Nango's OAuth flow. The control plane detects the new connection and sends a signal to your pod. Your pod then pulls data from the external service, classifies it into the appropriate entity profiles, and stores it locally.

This architecture is intentional. Your pod pulls data rather than having external services push to it. This means your pod controls when and how data enters, there is no public webhook endpoint exposed, and the sync process goes through the same permission and event chain system as any other write.

Currently supported connectors

Google Calendar

Syncs your calendar events as event entities. Each event gets start/end dates, location, attendees, and all-day flags mapped to the event profile properties. Calendar events are searchable and appear in calendar views alongside manually created events. Changes sync periodically — new events appear, updated events are refreshed, and deleted events are marked accordingly.

Google Contacts

Imports your contacts as contact entities (which extend the person profile). Name, email, phone, and organization are mapped to profile properties. Your contacts become part of your knowledge graph — linkable to tasks, events, deals, and any other entity.

GitHub

Syncs repositories and issues. Repository metadata becomes entity properties, and issues can be mapped to tasks or standalone entities. This is particularly useful for developer workflows where GitHub issues need to be tracked alongside other project data in a unified view.

The sync model in detail

The sync process follows these steps:

• You connect an external service in the Connectors settings panel
• Nango handles the OAuth flow and stores the access/refresh tokens securely
• The control plane detects the new connection and signals your pod
• Your pod calls the external service API through Nango and retrieves data
• Each item is classified into the appropriate entity profile
• Entities are created (or updated if they already exist) through the standard write path
• An external_import channel records every synced item for audit

Subsequent syncs are incremental — only new or changed items are pulled. The sync frequency depends on the connector: calendar events sync every few minutes for near-real-time updates, while contacts sync less frequently since they change rarely.

Connector data as regular entities

Once synced, connector data is indistinguishable from manually created entities. A Google Calendar event is a regular event entity. A GitHub issue is a regular entity with the appropriate profile. This means you can:

• Search across local and synced data with the same search bar
• Display synced entities in any view type (table, kanban, calendar, bento)
• Link synced entities to other entities (connect a contact to a deal, relate a GitHub issue to a project)
• Comment on synced entities using entity_comments channels
• Include synced entities in AI conversations and let the AI reason about them

Governance and the event chain

Connector syncs go through the same event chain as AI mutations. Every synced item creates an event in the immutable audit log. If a connector sync creates incorrect data, you can see exactly what happened in the event chain and roll back individual items. The proposal system can be configured to require approval for connector writes, giving you a review gate for external data before it enters your workspace.

Future connectors

The connector architecture is designed for extensibility. Upcoming integrations include Telegram (message ingestion and AI-powered structuring), Slack (channel history import), email (forward-to-pod with AI classification), and RSS feeds (article tracking). The system also supports webhook ingestion for custom sources — any service that can send an HTTP request can push data into your pod through a webhook endpoint that classifies and stores the payload as entities.

Related guides