---
title: "Gorgias Connector"
description: "Complete Gorgias integration guide for syncing helpdesk tickets, customer data, and support events with Brevo via Tajo."
url: https://tajo.io/docs/connectors/support/gorgias/
markdown: https://tajo.io/docs/connectors/support/gorgias.md
lang: en-US
robots: noindex
---

# Gorgias Connector

Connector status: Planned Not built yet. Tajo does not run this connector today.

| Source field | Destination field | Sample value |
| --- | --- | --- |
| `record.id` | `source_id` | `record_1042` |
| `record.updated_at` | `updated_at` | `2026-10-18T08:00:00Z` |
| `record.value` | `value` | `sample_value` |

Connect your Gorgias helpdesk to Brevo for support-driven customer engagement, post-ticket marketing flows, and unified customer experience analytics through Tajo.

## Overview

| Property | Value |
| --- | --- |
| **Platform** | Gorgias |
| **Category** | Support |
| **Setup Complexity** | Easy |
| **Official Integration** | No |
| **Data Synced** | Customers, Tickets, Events |
| **API Type** | REST API |
| **Authentication** | API Key + Email (Basic Auth) |
| **Base URL** | `https://{domain}.gorgias.com/api/` |

## Features

- **Ticket event sync** - Forward ticket creation, resolution, and CSAT events to Brevo timelines
- **Customer profile enrichment** - Sync Gorgias customer data including tags and custom fields to Brevo
- **Post-support campaigns** - Trigger Brevo workflows after ticket resolution for follow-up or upsell
- **Satisfaction tracking** - Sync CSAT survey results as Brevo contact attributes
- **Tag-based segmentation** - Mirror Gorgias customer tags as Brevo list memberships
- **Macro and rule events** - Track automated actions for operational analytics

## Prerequisites

Before you begin, ensure you have:

1. A Gorgias account with admin access
2. Your Gorgias subdomain (e.g., `yourstore.gorgias.com`)
3. An API key and associated email address
4. A Brevo account with API access
5. A Tajo account with an active subscription

## Authentication

Gorgias uses HTTP Basic Authentication with your account email and API key.

### Creating an API Key

1. Log in to your Gorgias dashboard
2. Navigate to **Settings** > **REST API**
3. Click **Create API Key** (or copy existing key)
4. Note your API base URL: `https://{domain}.gorgias.com/api/`

```bash
# Basic Auth: email as username, API key as password
curl -X GET "https://yourstore.gorgias.com/api/customers" \
  -u "admin@yourstore.com:$GORGIAS_API_KEY" \
  -H "Content-Type: application/json"
```

API Key Permissions

Gorgias API keys have full access to your account data. There is no scope-based permission model. Protect your API key and rotate it regularly.

### Connecting to Tajo

```bash
tajo connectors install gorgias \
  --domain yourstore.gorgias.com \
  --email admin@yourstore.com \
  --api-key $GORGIAS_API_KEY
```

## Configuration

### Basic Setup

```yaml
connectors:
  gorgias:
    enabled: true
    domain: "yourstore.gorgias.com"

    sync:
      customers: true
      tickets: true
      satisfaction_surveys: true
      tags: true

    lists:
      all_support_contacts: 35
      satisfied_customers: 36
      dissatisfied_customers: 37
```

### Field Mapping

Map Gorgias customer and ticket fields to Brevo contact attributes:

```yaml
field_mapping:
  # Customer fields
  id: GORGIAS_ID
  email: email
  name: FIRSTNAME
  phone: SMS

  # Support metrics
  nb_tickets: TICKET_COUNT
  last_ticket_date: LAST_SUPPORT_DATE
  last_ticket_channel: LAST_SUPPORT_CHANNEL
  avg_response_time: AVG_RESPONSE_TIME

  # CSAT data
  last_satisfaction_score: CSAT_SCORE
  satisfaction_count: CSAT_RESPONSES

  # Custom fields
  customer_type: CUSTOMER_TYPE
  vip_status: VIP_STATUS
```

### Event Mapping

```yaml
event_mapping:
  ticket.created: SUPPORT_TICKET_OPENED
  ticket.closed: SUPPORT_TICKET_RESOLVED
  ticket.reopened: SUPPORT_TICKET_REOPENED
  satisfaction_survey.created: CSAT_SURVEY_SENT
  satisfaction_survey.responded: CSAT_SUBMITTED
  customer.created: SUPPORT_CUSTOMER_CREATED
```

## API Endpoints

Tajo integrates with the following Gorgias REST API endpoints:

| Endpoint | Method | Purpose |
| --- | --- | --- |
| `/api/customers` | GET | List customers |
| `/api/customers/{id}` | GET | Retrieve a customer |
| `/api/customers` | POST | Create a customer |
| `/api/customers/{id}` | PUT | Update a customer |
| `/api/tickets` | GET | List tickets |
| `/api/tickets/{id}` | GET | Retrieve a ticket |
| `/api/tickets/{id}/messages` | GET | List ticket messages |
| `/api/tags` | GET | List tags |
| `/api/satisfaction-surveys` | GET | List CSAT surveys |
| `/api/satisfaction-surveys/{id}` | GET | Retrieve a survey |
| `/api/users` | GET | List agents |
| `/api/integrations` | GET | List integrations |
| `/api/events` | GET | List events |
| `/api/customers/{id}/custom-fields` | GET | Get custom field values |

## Code Examples

### Initialize Connector

```javascript
import { TajoClient } from '@tajo/sdk';

const tajo = new TajoClient({
  apiKey: process.env.TAJO_API_KEY,
  brevoApiKey: process.env.BREVO_API_KEY
});

await tajo.connectors.connect('gorgias', {
  domain: 'yourstore.gorgias.com',
  email: 'admin@yourstore.com',
  apiKey: process.env.GORGIAS_API_KEY
});
```

### Sync Customers to Brevo

```javascript
await tajo.connectors.sync('gorgias', {
  type: 'incremental',
  resources: ['customers'],
  since: '2024-01-01',
  batchSize: 30
});

const status = await tajo.connectors.status('gorgias');
console.log(status);
// {
//   connected: true,
//   lastSync: '2024-03-15T17:00:00Z',
//   customersCount: 14200,
//   ticketsTracked: 28600,
//   csatResponses: 3400
// }
```

### Handle Ticket Events via HTTP Integration

```javascript
// Gorgias can send HTTP requests via Rules or HTTP integrations
app.post('/webhooks/gorgias', async (req, res) => {
  const event = req.body;

  await tajo.connectors.handleEvent('gorgias', {
    type: 'ticket.updated',
    payload: {
      ticketId: event.ticket_id,
      status: event.status,
      customerEmail: event.customer?.email,
      channel: event.channel,
      tags: event.tags,
      satisfaction: event.satisfaction
    }
  });

  res.status(200).send('OK');
});
```

### Post-Resolution Campaign

```javascript
// Trigger a follow-up email after a support ticket is resolved
tajo.connectors.on('gorgias', 'ticket.closed', async (event) => {
  if (event.satisfaction_score >= 4) {
    await tajo.campaigns.trigger('post-support-upsell', {
      email: event.customer.email,
      params: {
        agent_name: event.assignee.name,
        ticket_subject: event.subject,
        resolution_time: event.resolution_time
      }
    });
  }
});
```

### Sync CSAT Data

```javascript
// Sync satisfaction survey results to Brevo attributes
await tajo.connectors.sync('gorgias', {
  type: 'incremental',
  resources: ['satisfaction_surveys'],
  since: '2024-01-01'
});
```

## Rate Limits

Gorgias enforces rate limits per account:

| Limit Type | Value |
| --- | --- |
| **API rate limit** | 2 requests per second |
| **Burst allowance** | Up to 5 requests in short bursts |
| **Pagination** | 30 items per page (default), max 100 |

Pagination Strategy

Gorgias uses cursor-based pagination with `cursor` and `limit` parameters. Tajo handles this automatically, requesting up to 100 items per page for maximum efficiency.

Gorgias returns `429 Too Many Requests` when rate limits are exceeded.

## Troubleshooting

### Common Issues

| Issue | Cause | Solution |
| --- | --- | --- |
| 401 Unauthorized | Invalid email or API key | Verify credentials in Gorgias Settings > REST API |
| 404 Not Found | Invalid endpoint or resource ID | Check API base URL includes your subdomain |
| Customers missing | No email on record | Gorgias requires email for customer matching |
| Tags not syncing | Tags not assigned to customers | Verify tags are on customer objects, not just tickets |
| Slow sync | Low rate limit | Gorgias limits to 2 req/s; full syncs take longer |

### Debug Mode

```yaml
connectors:
  gorgias:
    debug: true
    log_level: verbose
    log_api_calls: true
```

### Test Connection

```bash
tajo connectors test gorgias
# ✓ API authentication successful
# ✓ Customer list accessible
# ✓ Ticket data readable
# ✓ CSAT surveys available
# ✓ Tags listable
```

## Best Practices

1. **Use HTTP integrations for real-time** - Configure Gorgias Rules to send HTTP requests to Tajo on ticket events
2. **Sync CSAT data regularly** - Use satisfaction scores to drive re-engagement campaigns
3. **Map tags to segments** - Translate Gorgias customer tags into Brevo list memberships
4. **Handle pagination carefully** - With 2 req/s limits, plan for longer sync times on large datasets
5. **Link to e-commerce data** - Combine Gorgias support data with Shopify order data in Brevo
6. **Rotate API keys** - Since Gorgias keys have full access, rotate them periodically

## Security

- **Basic Auth** - Email and API key over HTTPS
- **HTTPS Only** - All API communication encrypted via TLS 1.2+
- **Full Access Keys** - No granular scoping (protect keys carefully)
- **IP Allowlisting** - Available on higher Gorgias plans
- **Encrypted Storage** - API credentials encrypted at rest in Tajo
- **SOC 2 Compliance** - Gorgias platform is SOC 2 Type II certified

## Related Resources

- [Twilio Flex Connector](https://tajo.io/docs/connectors/custom/twilio-flex)
- [Jira Connector](https://tajo.io/docs/connectors/custom/jira)
- [Shopify Connector](https://tajo.io/docs/connectors/ecommerce/shopify)
- [Brevo Contacts API](https://tajo.io/docs/contact-management)

## Open-Source Implementation Map

No official open-source repository was found in the current Tajo connector catalog for Gorgias. Keep this page focused on the verified public API contract and vendor documentation until an official schema, SDK, MCP server, or public integration repository is available.

### Tajo Revamp Checklist

- Verify authentication and scope requirements against the vendor documentation before each connector release.
- Document primary sync objects, external IDs, pagination strategy, and rate limits explicitly.
- Add smoke tests from public API examples rather than undocumented behavior.
- Capture webhook signature verification and replay protection when the vendor supports webhooks.
- Record gaps where no official public repository or schema exists so future maintainers know what still needs source-backed validation.
