---
title: "How to"
img: https://s3.us-east-2.amazonaws.com/unified-article-images/how_to-icon.png
date: 2026-04-10T12:43:00.000Z
tag: Product
description: "Support data is fragmented across tools like Zendesk, Intercom, Freshdesk, and ServiceNow. Each system exposes tickets, customers, and conversations..."
url: "https://unified.to/blog/how_to"
---

# How to
------
_April 10, 2026_

Support data is fragmented across tools like Zendesk, Intercom, Freshdesk, and ServiceNow. Each system exposes tickets, customers, and conversations differently.


This use case shows how to:

- sync tickets in real time
- retrieve full customer context
- track conversations
- triage and update tickets
- respond with notes

All through a single normalized API.


## Step 1: Listen for ticket events (real-time entry point)


Use [webhooks](/blog/replacing_polling_with_unified_webhooks_and_virtual_streams) where available to receive:

- ticket created
- ticket updated

This becomes your primary ingestion path.


Fallback:

- poll `/ticket` using `updated_gte` for integrations without webhook support

## Step 2: List tickets (backfill + recovery)


```typescript
const results = await sdk.ticketing.listTicketingTickets({
  connectionId,
  limit: 50,
  offset: 0,
  updated_gte: '2026-04-10T12:20:40.004Z',
  sort: 'updated_at',
  order: 'asc'
});
```


Use this for:

- initial sync
- missed webhook recovery
- periodic reconciliation

## Step 3: Retrieve a ticket


```typescript
const ticket = await sdk.ticketing.getTicketingTicket({
  connectionId,
  id: '1234'
});
```


Key fields:

- `customer_id`
- `subject`
- `description`
- `status`
- `priority`
- `category_id`
- `tags`
- `user_id`

This is your core support object.


## Step 4: Retrieve customer context


```typescript
const customer = await sdk.ticketing.getTicketingCustomer({
  connectionId,
  id: ticket.customer_id
});
```


Customer includes:

- `name`
- `emails[]`
- `telephones[]`
- `tags[]`

This allows:

- identifying the user
- grouping tickets by customer
- enriching support workflows

## Step 5: Retrieve conversation history (notes)


```typescript
const notes = await sdk.ticketing.listTicketingNotes({
  connectionId,
  ticket_id: ticket.id,
  limit: 50,
  sort: 'updated_at',
  order: 'asc'
});
```


Each note includes:

- `description`
- `customer_id`
- `ticket_id`
- `user_id`

Use this to:

- reconstruct conversation threads
- display agent replies
- power AI summarization or drafting

## Step 6: Classify and route the ticket


First, retrieve available categories:


```typescript
const categories = await sdk.ticketing.listTicketingCategories({
  connectionId,
  limit: 50
});
```


Then assign during triage:


```typescript
await sdk.ticketing.updateTicketingTicket({
  connectionId,
  id: ticket.id,
  ticketingTicket: {
    priority: 'high',
    category_id: 'billing_issues',
    user_id: 'agent_123',
    tags: ['vip', 'refund']
  }
});
```


This step standardizes:

- routing
- ownership
- classification

## Step 7: Respond to the ticket (create a note)


```typescript
await sdk.ticketing.createTicketingNote({
  connectionId,
  ticketingNote: {
    ticket_id: ticket.id,
    customer_id: ticket.customer_id,
    description: 'We've identified the issue and are processing your refund.',
    user_id: 'agent_123'
  }
});
```


This works across all integrated platforms without adapting to:

- Zendesk comments
- Intercom replies
- Freshdesk notes

## Step 8: Update ticket status


```typescript
await sdk.ticketing.updateTicketingTicket({
  connectionId,
  id: ticket.id,
  ticketingTicket: {
    status: 'CLOSED',
    closed_at: new Date().toISOString()
  }
});
```


Status is normalized:

- `ACTIVE`
- `CLOSED`

## Step 9: Keep data in sync


## Tickets

- Webhooks for real-time updates
- Poll with `updated_gte` as fallback

## Notes

- Webhooks where supported
- Poll `/note` with `updated_gte` if needed

```typescript
await sdk.ticketing.listTicketingNotes({
  connectionId,
  updated_gte: lastSyncTime
});
```


## Customers

- Poll-based sync for consistency
- Webhooks when available

## Categories

- Poll periodically (low change frequency)

## Final Architecture


This flow gives you:

- real-time ticket ingestion (webhooks)
- unified ticket + customer model
- full conversation reconstruction
- consistent triage and routing
- cross-platform response handling
- reliable fallback via polling

All without writing:

- per-platform ticket logic
- per-platform comment handling
- per-platform customer retrieval

## What this enables

- unified support dashboards
- AI support agents operating across tools
- automated ticket routing systems
- cross-platform analytics and reporting
- shared inbox experiences across multiple support systems

→ [Start your 30-day free trial](https://app.unified.to/login)


→ [Book a demo](https://calendly.com/d/cph9-g8n-jzg/connect-with-unified)