Skip to main content
GET
/
x
/
notifications
Get notifications
curl --request GET \
  --url https://xquik.com/api/v1/x/notifications \
  --header 'x-api-key: <api-key>'
import requests

url = "https://xquik.com/api/v1/x/notifications"

headers = {"x-api-key": "<api-key>"}

response = requests.get(url, headers=headers)

print(response.text)
const options = {method: 'GET', headers: {'x-api-key': '<api-key>'}};

fetch('https://xquik.com/api/v1/x/notifications', options)
.then(res => res.json())
.then(res => console.log(res))
.catch(err => console.error(err));
package main

import (
"fmt"
"net/http"
"io"
)

func main() {

url := "https://xquik.com/api/v1/x/notifications"

req, _ := http.NewRequest("GET", url, nil)

req.Header.Add("x-api-key", "<api-key>")

res, _ := http.DefaultClient.Do(req)

defer res.Body.Close()
body, _ := io.ReadAll(res.Body)

fmt.Println(string(body))

}
Requested result counts are upper bounds for paid authenticated calls. When remaining credits cannot cover the full page or ID list, Xquik returns fewer results. If zero paid results are affordable, it returns 402 insufficient_credits.
1 credit per result returned · All plans from $0.00012/credit
Requires a connected X account. Uses user-authenticated access.
Get notifications reads the connected account inbox. Use type=Mentions for mention triage, type=Verified for verified-account activity, or omit type for all notification rows. Store next_cursor only when has_next_page is true.
curl -G https://xquik.com/api/v1/x/notifications \
  --data-urlencode "type=Mentions" \
  -H "x-api-key: xq_YOUR_KEY_HERE" | jq

# Page 2
curl -G https://xquik.com/api/v1/x/notifications \
  --data-urlencode "type=Mentions" \
  --data-urlencode "cursor=abc123" \
  -H "x-api-key: xq_YOUR_KEY_HERE" | jq
function notificationsUrl({ cursor, type = "Mentions" }) {
  const params = new URLSearchParams({ type });
  if (cursor) params.set("cursor", cursor);
  return `https://xquik.com/api/v1/x/notifications?${params}`;
}

function toNotificationRows(page, { inboxType }) {
  return page.notifications.map((notification) => ({
    record_type: "notification",
    inbox_type: inboxType,
    notification_id: notification.id,
    notification_type: notification.type ?? null,
    message_preview: notification.message ?? null,
    created_at: notification.timestamp ?? null,
    source_endpoint: "GET /api/v1/x/notifications",
    page_next_cursor: page.has_next_page ? page.next_cursor : null,
  }));
}

async function saveNotificationRows(rows) {
  // Replace this with a private support inbox, CRM, queue, or agent memory write.
  return rows.length;
}

const inboxType = "Mentions";
const response = await fetch(notificationsUrl({ type: inboxType }), {
  headers: { "x-api-key": "xq_YOUR_KEY_HERE" },
});
const data = await response.json();
const rows = toNotificationRows(data, { inboxType });
await saveNotificationRows(rows);

// Paginate
if (data.has_next_page) {
  const next = await fetch(notificationsUrl({ type: inboxType, cursor: data.next_cursor }), {
    headers: { "x-api-key": "xq_YOUR_KEY_HERE" },
  });
  const nextRows = toNotificationRows(await next.json(), { inboxType });
  await saveNotificationRows(nextRows);
}
import requests

def to_notification_rows(page, inbox_type):
    return [
        {
            "record_type": "notification",
            "inbox_type": inbox_type,
            "notification_id": notification["id"],
            "notification_type": notification.get("type"),
            "message_preview": notification.get("message"),
            "created_at": notification.get("timestamp"),
            "source_endpoint": "GET /api/v1/x/notifications",
            "page_next_cursor": page["next_cursor"] if page["has_next_page"] else None,
        }
        for notification in page["notifications"]
    ]

def save_notification_rows(rows):
    # Replace this with a private support inbox, CRM, queue, or agent memory write.
    return len(rows)

inbox_type = "Mentions"
response = requests.get(
    "https://xquik.com/api/v1/x/notifications",
    params={"type": inbox_type},
    headers={"x-api-key": "xq_YOUR_KEY_HERE"},
)
data = response.json()
save_notification_rows(to_notification_rows(data, inbox_type))

# Paginate
while data["has_next_page"]:
    data = requests.get(
        "https://xquik.com/api/v1/x/notifications",
        params={"type": inbox_type, "cursor": data["next_cursor"]},
        headers={"x-api-key": "xq_YOUR_KEY_HERE"},
    ).json()
    save_notification_rows(to_notification_rows(data, inbox_type))
The Node.js and Python snippets normalize each page into notification triage rows. Keep full message text in private systems. Use notification_id, notification_type, created_at, inbox_type, and page_next_cursor for shared dashboards, queues, and agent handoffs.

Notification triage handoff

Use GET /api/v1/x/notifications when a support inbox, CRM workflow, or agent queue needs account-level activity for a connected X account. The endpoint returns compact notification rows, not full tweet or DM objects.

Mention queue

Use type=Mentions for replies and mentions that need a support or brand review queue.

Verified activity

Use type=Verified when verified-account activity should be routed ahead of the general inbox.

All inbox

Omit type or pass All when the workflow needs every notification row visible to the connected account.

Stable upserts

Store notifications[].id as notification_id for dedupe and replay-safe imports.

Private text

Keep notifications[].message in private support, CRM, or agent memory systems.

Next page

Store has_next_page and next_cursor; pass next_cursor back as cursor only when has_next_page is true.

Query parameters

type
string
Notification filter. All (default), Verified, or Mentions. Unrecognized values fall back to All.
cursor
string
Pagination cursor. Pass the next_cursor value from the previous response to fetch the next page.

Which inbox endpoint?

Account notifications

Use GET /x/notifications for connected-account notification rows with All, Verified, or Mentions filters.

Home timeline

Use GET /x/timeline for the connected account’s home timeline tweets.

Participant DMs

Use GET /x/dm/{userId}/history when the workflow needs private direct-message conversation rows.

Public mentions

Use GET /x/users/{id}/mentions when you need public mention timeline rows for a user.

Account monitor events

Use List events after account or keyword monitors have captured replayable webhook events.

Webhook delivery

Use Webhooks when notification-like activity should push to your system instead of being polled.

Headers

x-api-key
string
required
Your API key. Session cookie authentication is also supported.

Response

notifications
object[]
Array of notification objects.
has_next_page
boolean
Whether more notifications are available.
next_cursor
string
Opaque cursor for the next page. Empty string when no more results.
{
  "notifications": [
    {
      "id": "1893456789012345678",
      "type": "mention",
      "message": "@xquikcom Great tool!",
      "timestamp": "2026-02-24T10:00:00.000Z"
    }
  ],
  "has_next_page": true,
  "next_cursor": "DAADDAABCgABF..."
}
Last modified on May 25, 2026