Twitter keyword monitor status & query checks

{
  "id": "21",
  "query": "xquik OR \"x api\"",
  "eventTypes": [
    "tweet.new"
  ],
  "isActive": true,
  "createdAt": "2025-01-15T12:00:00Z",
  "nextBillingAt": "2025-01-15T13:00:00Z"
}

{
  "error": "invalid_input",
  "message": "Invalid input. Check the request body."
}

{
  "error": "unauthenticated",
  "message": "Authentication required. Provide a valid API key or bearer token."
}

{
  "error": "not_found",
  "message": "Resource not found."
}

{
  "error": "rate_limit_exceeded",
  "message": "Too many requests. Try again later.",
  "retryAfter": 60
}

GET

monitors

keywords

{id}

Twitter keyword monitor status & query checks

curl --request GET \
  --url https://xquik.com/api/v1/monitors/keywords/{id} \
  --header 'x-api-key: <api-key>'

const options = {method: 'GET', headers: {'x-api-key': '<api-key>'}};

fetch('https://xquik.com/api/v1/monitors/keywords/{id}', 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/monitors/keywords/{id}"

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

}

{
  "id": "<string>",
  "query": "<string>",
  "eventTypes": [
    "<string>"
  ],
  "isActive": true,
  "createdAt": "<string>",
  "nextBillingAt": "<string>"
}

Inspect one Twitter keyword monitor

Use this route when a workflow already stores one keyword monitor ID. It returns the exact X search query, tracked tweet events, active state, creation time, and next billing checkpoint. Use the list route when the ID is unknown. Check query before routing new matches. It holds the Twitter keyword search that created the monitor. Check eventTypes before assuming replies, quotes, reposts, or other tweet events are enabled.

Single-monitor question	Response field	Incident decision
Is this the intended search?	`id` and `query`	Stop if either value differs from the stored alert.
Can it capture new tweets?	`isActive`	Resume only when future polling is required.
Which tweet events qualify?	`eventTypes`	Compare the exact types with webhook subscriptions.
When is the next charge?	`nextBillingAt`	Confirm credits before the billing checkpoint.
Where are matching tweets?	`GET /events?keywordMonitorId={id}`	Inspect stored events separately from configuration.

Store id, query, eventTypes, isActive, and nextBillingAt together. Pass the same monitor ID to event filters, updates, deletion, and webhook workflows. Every step then refers to the same tracked search. Use this status check before pausing or editing a monitor. A successful read does not prove a matching tweet exists. Read the events endpoint for captured tweets, then open one event for its complete payload.

Free. This endpoint does not consume credits.

curl -X GET https://xquik.com/api/v1/monitors/keywords/21 \
  -H "x-api-key: xq_YOUR_KEY_HERE" |
  jq -c '{
    keyword_monitor_id: .id,
    query: .query,
    event_types: .eventTypes,
    is_active: .isActive,
    next_billing_at: .nextBillingAt,
    update_endpoint: "/api/v1/monitors/keywords/\(.id)",
    delete_endpoint: "/api/v1/monitors/keywords/\(.id)",
    events_endpoint: "/api/v1/events?keywordMonitorId=\(.id)",
    event_detail_endpoint_pattern: "/api/v1/events/{event_id}",
    webhooks_endpoint: "/api/v1/webhooks",
    deliveries_endpoint_pattern: "/api/v1/webhooks/{webhook_id}/deliveries"
  }'

const monitorId = "21";
const response = await fetch(`https://xquik.com/api/v1/monitors/keywords/${monitorId}`, {
  method: "GET",
  headers: { "x-api-key": "xq_YOUR_KEY_HERE" },
});
const monitor = await response.json();
const monitorState = {
  keyword_monitor_id: monitor.id,
  query: monitor.query,
  event_types: monitor.eventTypes,
  is_active: monitor.isActive,
  created_at: monitor.createdAt,
  next_billing_at: monitor.nextBillingAt,
  update_endpoint: `/api/v1/monitors/keywords/${monitor.id}`,
  delete_endpoint: `/api/v1/monitors/keywords/${monitor.id}`,
  events_endpoint: `/api/v1/events?keywordMonitorId=${monitor.id}`,
  event_detail_endpoint_pattern: "/api/v1/events/{event_id}",
  webhooks_endpoint: "/api/v1/webhooks",
  deliveries_endpoint_pattern: "/api/v1/webhooks/{webhook_id}/deliveries",
};
process.stdout.write(`${JSON.stringify(monitorState)}\n`);

import json
import requests

monitor_id = "21"
response = requests.get(
    f"https://xquik.com/api/v1/monitors/keywords/{monitor_id}",
    headers={"x-api-key": "xq_YOUR_KEY_HERE"},
)
monitor = response.json()
monitor_state = {
    "keyword_monitor_id": monitor["id"],
    "query": monitor["query"],
    "event_types": monitor["eventTypes"],
    "is_active": monitor["isActive"],
    "created_at": monitor["createdAt"],
    "next_billing_at": monitor["nextBillingAt"],
    "update_endpoint": f"/api/v1/monitors/keywords/{monitor['id']}",
    "delete_endpoint": f"/api/v1/monitors/keywords/{monitor['id']}",
    "events_endpoint": f"/api/v1/events?keywordMonitorId={monitor['id']}",
    "event_detail_endpoint_pattern": "/api/v1/events/{event_id}",
    "webhooks_endpoint": "/api/v1/webhooks",
    "deliveries_endpoint_pattern": "/api/v1/webhooks/{webhook_id}/deliveries",
}
print(json.dumps(monitor_state))

package main

import (
    "encoding/json"
    "log"
    "net/http"
    "os"
)

type KeywordMonitor struct {
    ID            string   `json:"id"`
    Query         string   `json:"query"`
    EventTypes    []string `json:"eventTypes"`
    IsActive      bool     `json:"isActive"`
    CreatedAt     string   `json:"createdAt"`
    NextBillingAt string   `json:"nextBillingAt"`
}

type KeywordMonitorState struct {
    KeywordMonitorID           string   `json:"keyword_monitor_id"`
    Query                      string   `json:"query"`
    EventTypes                 []string `json:"event_types"`
    IsActive                   bool     `json:"is_active"`
    CreatedAt                  string   `json:"created_at"`
    NextBillingAt              string   `json:"next_billing_at"`
    UpdateEndpoint             string   `json:"update_endpoint"`
    DeleteEndpoint             string   `json:"delete_endpoint"`
    EventsEndpoint             string   `json:"events_endpoint"`
    EventDetailEndpointPattern string   `json:"event_detail_endpoint_pattern"`
    WebhooksEndpoint           string   `json:"webhooks_endpoint"`
    DeliveriesEndpointPattern  string   `json:"deliveries_endpoint_pattern"`
}

func main() {
    monitorID := "21"
    req, err := http.NewRequest("GET", "https://xquik.com/api/v1/monitors/keywords/"+monitorID, nil)
    if err != nil {
        log.Fatal(err)
    }
    req.Header.Set("x-api-key", "xq_YOUR_KEY_HERE")

    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        log.Fatal(err)
    }
    defer resp.Body.Close()

    var monitor KeywordMonitor
    if err := json.NewDecoder(resp.Body).Decode(&monitor); err != nil {
        log.Fatal(err)
    }
    state := KeywordMonitorState{
        KeywordMonitorID:           monitor.ID,
        Query:                      monitor.Query,
        EventTypes:                 monitor.EventTypes,
        IsActive:                   monitor.IsActive,
        CreatedAt:                  monitor.CreatedAt,
        NextBillingAt:              monitor.NextBillingAt,
        UpdateEndpoint:             "/api/v1/monitors/keywords/" + monitor.ID,
        DeleteEndpoint:             "/api/v1/monitors/keywords/" + monitor.ID,
        EventsEndpoint:             "/api/v1/events?keywordMonitorId=" + monitor.ID,
        EventDetailEndpointPattern: "/api/v1/events/{event_id}",
        WebhooksEndpoint:           "/api/v1/webhooks",
        DeliveriesEndpointPattern:  "/api/v1/webhooks/{webhook_id}/deliveries",
    }
    if err := json.NewEncoder(os.Stdout).Encode(state); err != nil {
        log.Fatal(err)
    }
}

The cURL, Node.js, Python, and Go examples convert the fetched keyword monitor into one state snapshot row. Store keyword_monitor_id, query, event_types, is_active, next_billing_at, update_endpoint, delete_endpoint, events_endpoint, event_detail_endpoint_pattern, webhooks_endpoint, and deliveries_endpoint_pattern before changing filters, pausing alerts, or reconciling webhooks.

State handoff

Use GET /monitors/keywords/{id} before changing routing, billing checks, or alert state for one keyword monitor. The endpoint returns the current stored monitor for your account only. Deleted or cross-account IDs return 404.

Keyword monitor column	Response source	Decision rule
Monitor ID	`id`	Use this ID for updates, events, and deletion.
X search query	`query`	Compare the stored query with the intended search.
Tweet event filter	`eventTypes`	Align webhook subscriptions with these event types.
Polling state	`isActive`	Resume only when future tweet checks are required.
Creation time	`createdAt`	Keep the monitor creation timestamp.
Billing checkpoint	`nextBillingAt`	Review credits before the next active charge.
Missing monitor	`404 not_found`	Stop changes for deleted or cross-account IDs.

Current filter

query and eventTypes decide which tweets match. Copy eventTypes into List Webhooks before relying on signed alerts.

Active state

Use isActive to decide whether the monitor should poll and bill. Use Update Keyword Monitor to pause or resume it.

Billing check

Read nextBillingAt before credit alerts, budget checks, or account handoffs. Paused monitors stay visible but add no hourly charge.

Event join

Use id as keywordMonitorId with List Events to reconcile stored events and webhook deliveries for this query. Use Get Event for one event’s full payload.

Delivery audit

Use List Deliveries when you must retain webhook delivery evidence. Join delivery streamEventId to event IDs. Do not use x_event_id as the delivery join key.

Delete path

Use Delete Keyword Monitor only when the query should stop permanently. Export event and delivery evidence first when support or audit workflows need history.

Verify one alert before incident review

Inspect one stored monitor before investigating a missed or unexpected alert. Start with the monitor ID recorded by the alerting system. A list response does not show which row the workflow used. Compare the returned query with the intended Twitter search expression. Check capitalization, quoted phrases, exclusions, and operators. Store the returned value as evidence. Do not reconstruct it from a dashboard label. Next, compare eventTypes with the event under review. A monitor configured only for tweet.new cannot explain an expected reply alert. Update the filter only after recording its current value. Read isActive before examining an empty event window. A paused monitor stays available through this endpoint. It does not create future matching events. Check nextBillingAt when the monitor should be active. Use the returned ID to query stored events. Keep these outcomes separate:

The monitor exists, but its query does not match the expected tweet.
The query matches, but the required event type is absent.
The event type exists, but the monitor is paused.
The monitor is active, but no stored event matches the review window.
A stored event exists, but its webhook delivery needs inspection.

Open the matching event before diagnosing webhook delivery. Then join its event ID with streamEventId from delivery records. You can then tell a matching problem from a delivery problem. Finish with a short incident note. Record the monitor ID, exact query, active state, event types, event ID, and delivery result. That record lets another operator repeat the check without listing every monitor.

Diagnose one keyword monitor

Start with the returned monitor ID, query, event types, and active state. Check nextBillingAt and remaining credits before investigating a missing alert. Run the exact query through tweet search. Relevant results confirm query coverage, not webhook delivery. Inspect stored events by keywordMonitorId. Inspect delivery records by webhook ID. Keep streamEventId separate from each delivery ID. Do not edit the monitor during diagnosis. Capture its previous state before any approved change.

Prove a keyword alert with stored evidence

Collect evidence for the alert in 3 steps. Start with this endpoint’s monitor response. Save its ID, exact query, active state, and event types. Run the exact query through Tweet Search. Save matching Tweet IDs and creation times. A search match proves query coverage. It does not prove that a monitor stored an event. Next, list stored events for the same keyword monitor ID. Match the expected Tweet ID when the event payload exposes it. Save the event ID and event timestamp. An event proves the monitor stored the tweet. It does not prove webhook delivery. Finally, inspect deliveries for the subscribed webhook. Join each delivery’s streamEventId to the stored event ID. Record its status and attempt time. A delivery record proves Xquik sent the notification. Keep 3 outcomes separate:

Search found the tweet, but no monitor event exists.
A monitor event exists, but no delivery references it.
A delivery exists, but the receiving application rejected it.

Report each outcome separately. Each outcome needs a different correction. Query changes affect matching. Monitor state affects future event creation. Webhook changes affect delivery. Record the investigation window in UTC. Compare tweet, event, and delivery timestamps inside that window. Avoid using dashboard refresh time as evidence. Finish with one incident record. Include monitor ID, query, Tweet ID, event ID, webhook ID, and delivery result. Link every conclusion to a returned field. Another operator can then repeat the review.

Distinguish configuration drift from missing tweets

Compare the returned query with the approved query character by character. Check quoted phrases, exclusions, hashtags, usernames, and search operators. One missing operator can change every matched tweet. Compare eventTypes with the approved event scope. Keep the full returned array. Do not summarize several values as a broad monitoring label. Check isActive and nextBillingAt together. A stored monitor can remain visible while paused. A future billing timestamp tells you when the next charge is due. Neither field proves that a specific tweet created an event. Use Update Account Monitor only for account monitors. Keyword monitors use their dedicated update route. Keep monitor types separate when support tickets contain several IDs.

Path parameters

string

required

The unique keyword monitor ID. Returned when you create a keyword monitor or list keyword monitors.

Headers

string

required

Your API key. Session cookie authentication is also supported. Generate a key from the dashboard.

Response

200 OK

string

Unique keyword monitor ID.

string

Normalized X search query.

string[]

Subscribed event types.

boolean

Whether the monitor is active.

string

ISO 8601 creation timestamp.

string

Next hourly credit charge time for active monitor billing.

{
  "id": "21",
  "query": "xquik OR \"x api\"",
  "eventTypes": ["tweet.new"],
  "isActive": true,
  "createdAt": "2026-02-24T10:30:00.000Z",
  "nextBillingAt": "2026-02-24T11:30:00.000Z"
}

400 Invalid ID

{ "error": "invalid_id", "message": "Invalid ID format." }

The provided monitor ID is not a valid format.

401 Unauthenticated

{ "error": "unauthenticated", "message": "Missing or invalid API key" }

Missing or invalid API key.

404 Not found

{ "error": "not_found", "message": "Monitor not found" }

No keyword monitor exists with this ID, or it belongs to a different account.

429 Rate limited

{
  "error": "rate_limit_exceeded",
  "message": "Too many requests. Try again later.",
  "retryAfter": 1
}

Too many requests. Wait for the Retry-After header before retrying.

{
  "id": "21",
  "query": "xquik OR \"x api\"",
  "eventTypes": [
    "tweet.new"
  ],
  "isActive": true,
  "createdAt": "2025-01-15T12:00:00Z",
  "nextBillingAt": "2025-01-15T13:00:00Z"
}

{
  "error": "invalid_input",
  "message": "Invalid input. Check the request body."
}

{
  "error": "unauthenticated",
  "message": "Authentication required. Provide a valid API key or bearer token."
}

{
  "error": "not_found",
  "message": "Resource not found."
}

{
  "error": "rate_limit_exceeded",
  "message": "Too many requests. Try again later.",
  "retryAfter": 60
}

Twitter keyword monitor status & query checks

curl --request GET \
  --url https://xquik.com/api/v1/monitors/keywords/{id} \
  --header 'x-api-key: <api-key>'

const options = {method: 'GET', headers: {'x-api-key': '<api-key>'}};

fetch('https://xquik.com/api/v1/monitors/keywords/{id}', 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/monitors/keywords/{id}"

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

}

{
  "id": "<string>",
  "query": "<string>",
  "eventTypes": [
    "<string>"
  ],
  "isActive": true,
  "createdAt": "<string>",
  "nextBillingAt": "<string>"
}

Overview

X API

X write

Trends

Radar

Account

API keys

Guest wallets

Credits

X accounts

Monitors

Events

Webhooks

Draws

Extractions

Compose

Drafts

Styles

Support

Twitter keyword monitor status & query checks

Inspect one Twitter keyword monitor

State handoff

Current filter

Active state

Billing check

Event join

Delivery audit

Delete path

Verify one alert before incident review

Diagnose one keyword monitor

Prove a keyword alert with stored evidence

Distinguish configuration drift from missing tweets

Path parameters

Headers

Response

200 OK

400 Invalid ID

401 Unauthenticated

404 Not found

429 Rate limited

​Inspect one Twitter keyword monitor

​State handoff

Current filter

Active state

Billing check

Event join

Delivery audit

Delete path

​Verify one alert before incident review

​Diagnose one keyword monitor

​Prove a keyword alert with stored evidence

​Distinguish configuration drift from missing tweets

​Path parameters

​Headers

​Response

​200 OK

​400 Invalid ID

​401 Unauthenticated

​404 Not found

​429 Rate limited

Inspect one Twitter keyword monitor

State handoff

Verify one alert before incident review

Diagnose one keyword monitor

Prove a keyword alert with stored evidence

Distinguish configuration drift from missing tweets

Path parameters

Headers

Response

200 OK

400 Invalid ID

401 Unauthenticated

404 Not found

429 Rate limited