GraphQL API#

Authorization: Bearer YOUR_API_KEY
Content-Type: application/json

{
  __schema {
    types {
      name
      description
    }
  }
}

query Events($first: Int, $after: String, $eventTypes: [String!]) {
  events(first: $first, after: $after, eventTypes: $eventTypes) {
    edges {
      node {
        id
        eventTypeName
        payload
        createdAt
        processedAt
        edges {
          edgeType
          targetNodeType
          targetNodeId
        }
      }
      cursor
    }
    pageInfo {
      hasNextPage
      hasPreviousPage
      startCursor
      endCursor
      count
    }
  }
}

query Event($id: UUID!) {
  event(id: $id) {
    id
    eventTypeName
    payload
    createdAt
    originEventId
    edges {
      edgeType
      targetNodeType
      targetNodeId
    }
  }
}

mutation CreateEvent(
  $userId: UUID!
  $payload: JSON!
  $eventType: String
  $edges: [JSON!]
) {
  createEvent(
    userId: $userId
    payload: $payload
    eventType: $eventType
    edges: $edges
  ) {
    id
    eventTypeName
    payload
    createdAt
  }
}

mutation UpdateEvent($eventId: UUID!, $payload: JSON, $mergePayload: Boolean) {
  updateEvent(eventId: $eventId, payload: $payload, mergePayload: $mergePayload) {
    id
    payload
  }
}

mutation DeleteUserEvents($userId: UUID!, $before: DateTime, $since: DateTime) {
  deleteUserEvents(userId: $userId, before: $before, since: $since)
}

query { eventCursorAtDatetime(datetime: "2024-06-01T00:00:00Z") }

query { eventCursor(eventId: "event-uuid") }

query { eventTypeStats(days: 30) { entityId date count } }

query { eventTypeLastActivity { eventType lastEventAt } }

query { resolveId(prefix: "msg", userId: "user-uuid", recordType: "event") }

query Users($first: Int, $search: String, $orderBy: String) {
  users(first: $first, search: $search, orderBy: $orderBy) {
    edges {
      node {
        id
        name
        isSystemUser
        lastActiveAt
        createdAt
        identities {
          id
          externalId
          identityType
          platformConnection { id platformName }
        }
      }
      cursor
    }
    pageInfo {
      hasNextPage
      endCursor
      count
    }
  }
}

# Only system users
users(configFilters: [{ field: "system_user", value: "true" }]) { ... }

query {
  identities(identityType: "whatsapp", limit: 50) {
    id
    externalId
    identityType
    user { id name }
    platformConnection { id platformName }
  }
}

mutation CreateUser($name: String, $isSystemUser: Boolean) {
  createUser(name: $name, isSystemUser: $isSystemUser) {
    id
    name
    isSystemUser
    createdAt
  }
}

mutation CreateIdentity(
  $userId: UUID!
  $externalId: String!
  $identityType: String!
  $config: JSON
) {
  createIdentity(
    userId: $userId
    externalId: $externalId
    identityType: $identityType
    config: $config
  ) {
    id
    externalId
    identityType
    user { id name }
  }
}

mutation TransferIdentities(
  $sourceUserId: UUID!
  $targetUserId: UUID!
  $deleteSourceUser: Boolean
  $deleteSourceConversations: Boolean
) {
  transferIdentities(
    sourceUserId: $sourceUserId
    targetUserId: $targetUserId
    deleteSourceUser: $deleteSourceUser
    deleteSourceConversations: $deleteSourceConversations
  ) {
    id
    name
    identities { id externalId }
  }
}

mutation { transferIdentity(identityId: "id-uuid", targetUserId: "user-uuid") { id externalId } }

mutation { deleteIdentity(identityId: "id-uuid") }

mutation { deleteUser(id: "user-uuid") }

query {
  conversations(first: 25, search: "Alice") {
    edges {
      node {
        id
        title
        createdAt
        updatedAt
        messageCount
        participants { userId userName }
      }
      cursor
    }
    pageInfo { hasNextPage endCursor count }
  }
}

query {
  userConversations(userId: "user-uuid", limit: 50) {
    id
    title
    messageCount
    participants { userId userName }
  }
}

mutation {
  deleteConversations(conversationIds: ["conv-uuid-1"], deleteMessages: true)
}

mutation SendMessage(
  $message: String
  $recipientUserId: UUID
  $conversationId: UUID
  $platform: PlatformName
  $platformConnectionId: UUID
  $fileIds: [UUID!]
  $template: JSON
) {
  sendMessage(
    message: $message
    recipientUserId: $recipientUserId
    conversationId: $conversationId
    platform: $platform
    platformConnectionId: $platformConnectionId
    fileIds: $fileIds
    template: $template
  ) {
    id
    eventTypeName
    payload
    createdAt
  }
}

query {
  files(fileIds: ["file-uuid-1", "file-uuid-2"]) {
    id
    filename
    mimeType
    size
    url
    createdAt
  }
}

query {
  edges(eventIds: ["evt-uuid-1", "evt-uuid-2"], edgeType: "sent_by") {
    id
    edgeType
    sourceNodeId
    sourceNodeType
    targetNodeId
    targetNodeType
    extraData
  }
}

mutation {
  createEdge(
    sourceNodeId: "event-uuid"
    sourceNodeType: "event"
    targetNodeId: "user-uuid"
    targetNodeType: "user"
    edgeType: "relates_to"
    extraData: { note: "custom data" }
  ) {
    id
    edgeType
  }
}

mutation {
  generateLinkCode(
    identityId: "identity-uuid"
    maxUses: 1
    expiryMinutes: 15
    sendToUser: true
  ) {
    id
    payload
  }
}

mutation {
  redeemLinkCode(code: "1234-5678-9012-3456", identityId: "identity-uuid") {
    id
    payload
  }
}

query {
  logs(eventId: "event-uuid", logLevel: "error", limit: 50) {
    id
    logLevel
    logType
    message
    payload
    createdAt
  }
}

mutation {
  createLog(
    message: "Processing completed"
    logLevel: "info"
    logType: "execution"
    payload: { duration_ms: 42 }
    eventId: "event-uuid"
  ) {
    id
    createdAt
  }
}

query {
  stats(
    sourceType: EVENT_TYPE
    startDate: "2024-01-01T00:00:00Z"
    endDate: "2024-02-01T00:00:00Z"
    granularity: DAILY
    entityId: "message.inbound"
  ) {
    timestamp
    count
    entityId
  }
}

query {
  getStats(timeframe: LAST_30_DAYS) {
    identitiesCount
    messagesCount
    usersCount
  }
}

enum PlatformName {
  WHATSAPP
  INSTAGRAM
  FACEBOOK
  TELEGRAM
  SLACK
  DISCORD
  TWILIO
  EMAIL
  IMESSAGE
  CUSTOM
  UNKNOWN
}

enum StatsSourceType {
  EVENT
  EVENT_TYPE
  API_KEY
  PLATFORM_CONNECTION
  WEBHOOK
  USER
  APPLICATION
}

enum StatsGranularity {
  ONE_MINUTE
  FIVE_MINUTE
  FIFTEEN_MINUTE
  HOURLY
  SIX_HOURLY
  DAILY
  WEEKLY
}

enum Timeframe {
  LAST_30_DAYS
  ALL_TIME
}

query {
  events(first: 20, after: "cursor_xyz") {
    edges {
      node { id }
      cursor
    }
    pageInfo {
      hasNextPage
      endCursor
    }
  }
}

query {
  events(last: 20, before: "cursor_xyz") {
    edges {
      node { id }
      cursor
    }
    pageInfo {
      hasPreviousPage
      startCursor
    }
  }
}

mutation {
  sendMessage(
    message: "Your order has shipped"
    recipientUserId: "user-uuid"
    idempotencyKey: "b3c5a7de-8f21-4f6e-9c44-1a2b3c4d5e6f"
  ) {
    id
  }
}

{
  "data": null,
  "errors": [
    {
      "message": "Platform connection not found",
      "locations": [{"line": 2, "column": 3}],
      "path": ["sendMessage"]
    }
  ]
}

query BatchQuery {
  events(first: 10) {
    edges { node { id } }
  }
  users(first: 10) {
    edges { node { id } }
  }
}