How to

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 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)

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

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

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)

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:

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

Then assign during triage:

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)

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

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

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

→ Book a demo