# Octadesk Connector: BigQuery, Redshift, PostgreSQL, and more integrations without manual pipelines > Managed connector syncs Octadesk chats, tickets, contacts, and survey submissions to BigQuery, Redshift, and more. No pipeline needed. Source: https://www.erathos.com/en/blog/octadesk-connector-launch Em português: https://www.erathos.com/blog/octadesk-connector-launch Published: 2026-06-03 Category: New Connectors ![Octadesk](https://cms-media.erathos.com/B2kNeWC1MM0978OZrMNtnhm2doU-1.png) Managed connector to sync chats, messages, tickets, contacts, organizations, and survey submissions from Octadesk to BigQuery, Redshift, Databricks, ClickHouse, PostgreSQL, Supabase, Azure Synapse, and Amazon S3. Create your account and test it now. Octadesk exposes a REST API authenticated via API Key, which theoretically allows you to build your own extraction. In practice, this means writing and maintaining a custom [ETL pipeline](/blog/etl-vs-elt-principais-diferencas) to handle pagination, rate limiting, and schema changes, something most data teams realize too late doesn't scale. The Erathos connector handles this integration as a managed service, without requiring your team to write or maintain this code. Every data team supporting a company with a CX operation eventually reaches the same bottleneck: customer service data lives in Octadesk, the rest of the analytical stack lives in the data warehouse, and joining the two becomes an unplanned engineering project. What starts as a Python script running on an EC2 cron job turns, three months later, into a pipeline that nobody understands, that fails silently, and that no engineer wants to inherit. Erathos launches the managed connector for Octadesk. Fifteen endpoints available, eight supported destinations, zero pipeline code to write or maintain. ### The problem with custom-built Octadesk pipelines The Octadesk API is authenticated via API Key, with the account's base URL (`https://yourcompany.octadesk.services`) varying per tenant. The pattern is simple enough to convince any engineer to build a quick in-house integration in an afternoon. The real cost comes later, and it is predictable. **Non-uniform pagination per endpoint.** Chats and messages have different volumes and pagination behaviors compared to tickets and contacts. Logic that works for one doesn't necessarily work for the other, and when Octadesk adjusts a default page size or changes the cursor, the pipeline stops pulling all records without throwing an error. **Silent rate limiting.** The Octadesk API operates with rate limiting. In a normal incremental extraction for mid-sized volumes, you stay below the limit. But when doing a historical backfill or when the customer's Salesforce is triggering cascading events, the pipeline starts getting `429`s. If your retry logic isn't properly implemented with exponential backoff, you lose entire data windows without knowing it. **Unannounced schema evolution.** New fields appear, existing fields become `nullable`, nested structures change. Your dbt model that used to run smoothly starts failing in production, or worse, keeps running but coalescing a field that disappeared. The inconsistency hits the CS team's dashboard before it ever reaches your monitoring tool. **Non-existent observability.** A `200 OK` on an HTTP call doesn't mean the data arrived correctly. Without record counts per endpoint per run, without comparison to the previous window, and without volume drop alerts, you are flying blind. A pipeline that ran successfully might have pulled zero new tickets because the cursor got stuck. The worst-case scenario isn't the pipeline that breaks and sends an alert. It's the pipeline that runs successfully and delivers wrong data, while the SLA metric that goes up to the CS dashboard is already calculated on top of a broken source. ### What you can do once Octadesk data hits your warehouse Before detailing the connector, it's worth documenting what you actually gain when this data leaves the SaaS silo and enters modeled alongside the rest of your stack. #### End-to-end SLA analysis with joined data With `tickets` and `ticket_interactions` in your warehouse, you can calculate first response time, resolution time by type, and channel precision per record, not as an aggregate exported from the Octadesk UI. This model doesn't exist natively in any Octadesk dashboard. It's only possible when the data is in your warehouse, right next to the other tables in your model. #### Combine customer support with product and CRM data By joining `contacts` and `organizations` with your CRM account table (Salesforce, HubSpot, or whatever is in your warehouse), you can answer questions like: do enterprise customers have a better SLA than starter plan customers? Which organizations open the most repeat tickets for the same issue? Which channels have the highest reopening rate? These questions seem simple, but they require Octadesk `organizations` and CRM `accounts` to live in the same warehouse and be joined by a business field (usually email domain or an external ID). #### Sentiment and feedback analysis with survey submissions The `survey_submissions` endpoint brings CSAT and NPS responses collected by Octadesk. With this in the warehouse, you can model NPS trends by customer cohort, identify which ticket types drive the lowest satisfaction, and join CSAT with product data to close the loop between product experience and support quality. #### Volume and performance by channel and group With `ticket_channels`, `ticket_groups`, and `ticket_status`, you can build a throughput view per queue with daily or hourly granularity. Unlike Octadesk's native reports, which are pre-aggregated, here you have the raw data to build any time window or dimension the business needs. #### Analyze WhatsApp and chat conversations with chats and messages The `chats` and `messages` endpoints bring conversation history. This opens up possibilities for volume analysis by hour, identifying peak demand, keyword categorization, and even integration with LLMs for automatic intent classification, all outside of Octadesk, in your own environment. ### What is available in the connector The Octadesk connector delivers fifteen endpoints ready to be materialized in your destination warehouse: Endpoint What it contains `chats` Chat and WhatsApp conversations `messages` Individual messages per conversation `events` Platform events `contacts` Registered contacts `tickets` Support tickets `ticket_interactions` Interactions and replies per ticket `ticket_tags` Tags applied to tickets `ticket_groups` Support groups `ticket_forms` Ticket creation forms `ticket_priorities` Configured priorities `ticket_types` Ticket types `ticket_channels` Support channels `ticket_status` Ticket statuses `organizations` Organizations/accounts `survey_submissions` CSAT and NPS responses Supported destinations are **BigQuery**, **Redshift**, **Databricks**, **ClickHouse**, **PostgreSQL**, **Supabase**, **Azure Synapse**, and **Amazon S3**. ### How to authenticate Connector authentication requires three fields: - **URL**: the base URL of your Octadesk account (e.g., `https://yourcompany.octadesk.services`) - **Token**: your account's API Key - **Agent Email**: the Octadesk agent email associated with the key To find the token within Octadesk, navigate to **Settings > WhatsApp API > Generate API Key** (Generate apiKey). The base URL is available in the same path under **Settings > WhatsApp API > Base URL**. The full process is documented at [docs.erathos.com/connectors/apis/octadesk](https://docs.erathos.com/connectors/apis/octadesk). ### Why outsource ingestion to Erathos The connector's premise is straightforward: maintaining ingestion pipelines shouldn't be your data team's responsibility. Pagination, rate limits, retry with backoff, schema evolution, failure alerts, volume drop alerts, backfills. All of this is the responsibility of whoever operates the ingestion platform. It's the same rationale behind [modernizing legacy ETL processes](/blog/modernizacao-processos-etl): replacing hand-crafted maintenance with a SaaS solution that assumes operational responsibility. With the connector configured, the platform delivers: **End-to-end visibility of every run.** Extraction time per endpoint, record counts per window, which windows were processed, and where retries occurred. When an SLA metric changes on the dashboard and the CS team opens a ticket for the data team, you have the full lineage to find the root cause. **Out-of-the-box alerting.** Run failures, volume drops per endpoint, and sync lag are automatically detected and routed through the alerting integrations your team already uses. You don't write this code. **Reprocessing as a native operation.** When you need to reprocess a window (because you changed your dbt model logic or received a source fix), it's a platform operation, not an improvised sequence of DELETE + INSERT queries in your warehouse. Proper pagination, rate limit management, schema evolution, and backfills are handled by the platform. The data team focuses on modeling, not plumbing. ### Frequently asked questions about the Octadesk connector **Does Octadesk have an API request limit?** Yes. The Octadesk API applies rate limiting, and poorly implemented extractions return 429 errors during backfills or volume spikes. The Erathos connector handles this automatically via exponential backoff retry logic, with no intervention required from your data team. **Do I need technical knowledge to connect Octadesk to my warehouse?** No. Authentication only requires three fields (account URL, API Key, and agent email). There is no need to write any pipeline code. **Does the connector support incremental sync?** Yes, all fifteen endpoints, including tickets, chats, contacts, and survey submissions, are synced incrementally after the initial historical load. **What Octadesk data can I bring to my warehouse?** Chats, messages, tickets, ticket interactions, contacts, organizations, support groups and channels, and CSAT/NPS feedback via survey submissions. The full list is in the endpoints table above. **Which destinations does the Octadesk connector sync data to?** BigQuery, Redshift, Databricks, ClickHouse, PostgreSQL, Supabase, Azure Synapse, and Amazon S3. ### Available pipelines The Octadesk connector is available with the following destinations: - [Octadesk → BigQuery](/pipelines/octadesk-bigquery) - [Octadesk → Redshift](/pipelines/octadesk-redshift) - [Octadesk → Databricks](/pipelines/octadesk-databricks) - [Octadesk → ClickHouse](/pipelines/octadesk-clickhouse) - [Octadesk → PostgreSQL](/pipelines/octadesk-postgresql) - [Octadesk → Supabase](/pipelines/octadesk-supabase) - [Octadesk → Amazon S3](/pipelines/octadesk-amazon-s3) ### Get started now [Create your Erathos account](https://app.erathos.com/signup?slug=blog&button=cta&utm_campaign=octadesk_release) and connect Octadesk to your warehouse in minutes. With your base URL, token, and agent email, your first data loads into your destination with no pipeline code to write, maintain, or monitor. Customer service data generated every day shouldn't stay locked in a SaaS silo, disconnected from the rest of your analytical models. Or worse, in a home-grown pipeline that will cost your team's attention every single month forever. _Check the full connector documentation at_ [_docs.erathos.com/connectors/apis/octadesk_](https://docs.erathos.com/connectors/apis/octadesk)_._