Delete Twitter Account Monitor & Stop Monitoring

{
  "success": true
}

{
  "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
}

DELETE

monitors

{id}

Delete Twitter Account Monitor & Stop Monitoring

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

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

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

	req, _ := http.NewRequest("DELETE", 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))

}

{
  "success": true
}

This endpoint deletes one saved Xquik account monitor. It stops future tweet and profile checks. It removes stored events and linked webhook delivery records. The tracked X account and its profile remain unchanged. Its tweets, followers, and following list also remain unchanged.

This operation is permanent. Pause the monitor when its alerts may resume.

Free - does not consume credits

curl -X DELETE https://xquik.com/api/v1/monitors/7 \
  -H "x-api-key: xq_YOUR_KEY_HERE" |
  jq -c '{
    monitor_id: "7",
    success: .success == true,
    verify_endpoint: "/api/v1/monitors/7",
    list_endpoint: "/api/v1/monitors",
    events_endpoint: "/api/v1/events?monitorId=7",
    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 = "7";
const response = await fetch(`https://xquik.com/api/v1/monitors/${monitorId}`, {
  method: "DELETE",
  headers: {
    "x-api-key": "xq_YOUR_KEY_HERE",
  },
});
const result = await response.json();
const deletionReceipt = {
  monitor_id: monitorId,
  success: result.success === true,
  verify_endpoint: `/api/v1/monitors/${monitorId}`,
  list_endpoint: "/api/v1/monitors",
  events_endpoint: `/api/v1/events?monitorId=${monitorId}`,
  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(deletionReceipt)}\n`);

import json
import requests

monitor_id = "7"
response = requests.delete(
    f"https://xquik.com/api/v1/monitors/{monitor_id}",
    headers={"x-api-key": "xq_YOUR_KEY_HERE"},
)
result = response.json()
deletion_receipt = {
    "monitor_id": monitor_id,
    "success": result["success"] is True,
    "verify_endpoint": f"/api/v1/monitors/{monitor_id}",
    "list_endpoint": "/api/v1/monitors",
    "events_endpoint": f"/api/v1/events?monitorId={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(deletion_receipt))

package main

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

type DeleteResult struct {
    Success bool `json:"success"`
}

type AccountMonitorDeletion struct {
    MonitorID                 string `json:"monitor_id"`
    Success                   bool   `json:"success"`
    VerifyEndpoint            string `json:"verify_endpoint"`
    ListEndpoint              string `json:"list_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 := "7"
    req, err := http.NewRequest(
        "DELETE",
        "https://xquik.com/api/v1/monitors/"+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 result DeleteResult
    if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
        log.Fatal(err)
    }
    receipt := AccountMonitorDeletion{
        MonitorID:                 monitorID,
        Success:                   result.Success,
        VerifyEndpoint:            "/api/v1/monitors/" + monitorID,
        ListEndpoint:              "/api/v1/monitors",
        EventsEndpoint:            "/api/v1/events?monitorId=" + monitorID,
        EventDetailEndpointPattern: "/api/v1/events/{event_id}",
        WebhooksEndpoint:          "/api/v1/webhooks",
        DeliveriesEndpointPattern: "/api/v1/webhooks/{webhook_id}/deliveries",
    }
    if err := json.NewEncoder(os.Stdout).Encode(receipt); err != nil {
        log.Fatal(err)
    }
}

The cURL, Node.js, Python, and Go examples convert the delete response into one receipt row. Store monitor_id, success, verify_endpoint, list_endpoint, events_endpoint, event_detail_endpoint_pattern, webhooks_endpoint, and deliveries_endpoint_pattern, then verify that the deleted ID no longer appears in the list and that the verify endpoint returns 404.

Delete a Twitter Account Monitor Safely

Delete only when the account monitor should never run again. Confirm the monitor ID, X username, X user ID, and event types first. Save required tweet and profile events before deletion. Record the approver and final monitor identity in your own system. Use keyword monitor deletion only for a keyword monitor. Keep other account and keyword monitors when their checks must continue.

Path parameters

string

required

The unique monitor ID.

Headers

string

required

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

Response

200 OK

boolean

Always true on successful deletion.

{ "success": true }

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 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": 60 }

Too many requests. Follow the Retry-After interval before another request.

Does This Delete the X Account or Its Tweets?

No. This route deletes an Xquik account monitor only. This route cannot deactivate X accounts. It does not remove tweets, followers, following, replies, or likes. It also keeps reposts, media, lists, communities, and profile details. The tracked X account remains unchanged. Its public activity remains available through the applicable X API endpoints. Only Xquik’s saved monitor and related monitor records are removed.

Should I Pause or Delete Account Monitoring?

Pause when alerts may resume. Send isActive: false through Update Monitor. Pausing preserves the monitor ID, profile, event filters, and stored history. It stops future checks, deliveries, and hourly monitor billing. Delete when monitoring is permanently retired. Deletion removes the saved monitor and its stored history. A replacement monitor receives another ID.

Decision	Use it when	Result
Pause	Account monitoring may resume.	Keeps the monitor and history.
Update filters	Only future tweet or profile coverage changes.	Replaces `eventTypes`.
Delete	The monitor and its history are no longer required.	Permanently removes both.

What Does Monitor Deletion Remove?

Deleting the monitor removes its settings and stored tweet events. It also removes stored profile events, search records, and webhook delivery attempts. These records depend on the deleted monitor. Webhook endpoints remain configured. Existing endpoints can serve another monitor with matching event subscriptions. Other account monitors and keyword monitors remain active.

How Do I Verify Monitor Deletion?

Save the monitor ID before sending DELETE.
Require 200 with { "success": true }.
Read the same monitor and expect 404 not_found.
List monitors and confirm the ID is absent.
Treat another DELETE response of 404 as already removed.

Do not treat a network timeout as deletion proof. Confirm the monitor state before another deletion request. Wait for Retry-After after a 429 response.

Deletion handoff

Use this endpoint when a tracked account should stop permanently. Use Update Monitor with isActive: false when you only need to pause alerts and keep the monitor available.

Account monitor deletion check	Source	Completion rule
Delete receipt	`success`	Continue only when the response is `true`.
Monitor inventory	`GET /monitors`	Confirm the deleted monitor ID is absent.
Detail lookup	`GET /monitors/{id}`	Expect `404 not_found` after deletion.
Stored events	`GET /events?monitorId={id}`	Save required tweet and profile events first.
Delivery history	`GET /webhooks/{id}/deliveries`	Preserve required delivery evidence first.
Temporary stop	`PATCH /monitors/{id}`	Use `isActive: false` instead of deletion.

Plan Retention Before Monitor Deletion

Deletion cascades through stored events and linked delivery records. Decide which records your team must keep before sending DELETE. Export required tweet events, profile events, and relationship events first. Keep each event’s id, type, monitorId, username, and occurredAt. Preserve the complete data object for downstream tweet or profile processing. Support teams may also need webhook delivery evidence. Save delivery status, attempt counts, receiver responses, errors, and timestamps before deletion. Store these records in your approved system. Never place API keys in exports. Deletion does not create an archive. Xquik cannot return deleted monitor events through the events endpoints later. Finish retention checks before approval.

Select the Exact Twitter Account Monitor

Never select a monitor from a display label alone. Read the account monitor and compare its id, username, xUserId, eventTypes, and isActive values. Use List Monitors when the monitor ID is unknown. Then use Get Monitor to confirm the selected record. Record the final identity beside the approval. Delete account monitors and keyword monitors through their matching routes. Use Delete Keyword Monitor for a keyword query. Never send a keyword monitor ID to this account monitor endpoint. The route deletes by Xquik monitor ID. It does not delete by X username. This boundary prevents an account name from selecting several monitor records.

Preserve Tweet and Profile Events

Call List Events with the selected monitorId. Follow every cursor until hasMore becomes false. Complete every cursor page to include older tweet and profile events. Use Get Event for every event needing full detail. Keep event.id as the stable Xquik event identifier. Keep event.type to separate tweets, followers, profile changes, and relationship changes. Store occurredAt with each event payload. It records when Xquik observed the event. Keep the monitor ID with every exported row. This association supports later reconciliation after the monitor record disappears. Validate the export before deletion. Compare exported IDs with the final list response. Retry incomplete pages before approving monitor removal.

Preserve Webhook Delivery Evidence

List configured endpoints through List Webhooks. Then call List Deliveries for each relevant endpoint. Join each delivery’s streamEventId to the exported event id. Do not use x_event_id as the delivery join key. That value identifies an external event, not the stored Xquik event row. Keep status, attempts, lastStatusCode, lastError, createdAt, and deliveredAt. These fields explain successful deliveries, receiver failures, and exhausted attempts. Deleting the monitor removes linked delivery attempts. It does not remove the webhook endpoint. Reuse that endpoint when another monitor emits matching event types. Test the endpoint before depending on new alerts.

Handle Every Delete Response

A 200 response confirms the deletion. Require success: true before closing the workflow. Store the monitor ID beside that receipt. A 400 response means the ID format is invalid. Correct the path value before another request. Do not substitute an X username for the monitor ID. A 401 response means authentication failed. Replace the invalid API key or session. Never expose that credential in logs or support tickets. Treat a 404 response as an unavailable monitor. It may already be deleted. It may also belong to another account. Verify the account context before proceeding. A 429 response means the rate limit blocked the request. Read Retry-After, wait for that interval, and check the monitor again.

Resolve an Unknown Delete Result

A client timeout does not prove failure. The server may have completed the deletion before the connection ended. Read the same monitor ID after the timeout. A 404 response confirms that the record is unavailable. A successful read shows that the monitor still exists. List account monitors as a second check. Confirm that the deleted ID is absent. Do not rely on an empty event search alone. An event filter can be wrong while the monitor still exists. Repeated deletion leaves the final state unchanged. However, the response changes. The first completed request returns 200; later requests return 404 because the monitor no longer exists.

Recreate Monitoring After Deletion

A deleted account monitor cannot resume. Create another monitor when checks must restart. The replacement receives a different monitor ID. Use the saved X username, X user ID, and event types for reconstruction. Review those values before creating the replacement. Do not assume the old filters still match the current workflow. Existing webhook endpoints remain available. Confirm their event subscriptions before connecting the replacement monitor. Run Test Webhook to validate receiver access and response handling. Update downstream jobs with the new monitor ID. Replace stored event filters, verification links, and support references. The deleted ID will continue returning 404.

Account Monitor Deletion Checklist

Confirm the monitor ID, X username, and X user ID.
Review eventTypes, isActive, and the deletion reason.
Export every required tweet and profile event.
Preserve required webhook delivery attempts and receiver results.
Obtain approval for permanent removal.
Send DELETE and require 200 with success: true.
Read the deleted ID and require 404 not_found.
List monitors and confirm that the ID is absent.
Update downstream references to the removed monitor.

Pause with isActive: false when monitoring may resume. Delete only after the retention, approval, and verification steps finish. Use List Monitors to find and verify account monitors. Use Get Monitor to confirm the selected ID and its final 404 response. Use List Events and Get Event to retain tweet and profile evidence. Use List Webhooks and List Deliveries for delivery evidence. Use Create Monitor when a replacement account monitor is required. Store the new ID before restoring dependent workflows.

{
  "success": true
}

{
  "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
}

Delete Twitter Account Monitor & Stop Monitoring

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

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

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

	req, _ := http.NewRequest("DELETE", 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))

}

{
  "success": true
}

​Delete a Twitter Account Monitor Safely

​Path parameters

​Headers

​Response

​200 OK

​400 Invalid ID

​401 Unauthenticated

​404 Not Found

​429 Rate Limited

​Does This Delete the X Account or Its Tweets?

​Should I Pause or Delete Account Monitoring?

​What Does Monitor Deletion Remove?

​How Do I Verify Monitor Deletion?

​Deletion handoff

​Plan Retention Before Monitor Deletion

​Select the Exact Twitter Account Monitor

​Preserve Tweet and Profile Events

​Preserve Webhook Delivery Evidence

​Handle Every Delete Response

​Resolve an Unknown Delete Result

​Recreate Monitoring After Deletion

​Account Monitor Deletion Checklist

​Related Account Monitor Operations

Delete a Twitter Account Monitor Safely

Path parameters

Headers

Response

200 OK

400 Invalid ID

401 Unauthenticated

404 Not Found

429 Rate Limited

Does This Delete the X Account or Its Tweets?

Should I Pause or Delete Account Monitoring?

What Does Monitor Deletion Remove?

How Do I Verify Monitor Deletion?

Deletion handoff

Plan Retention Before Monitor Deletion

Select the Exact Twitter Account Monitor

Preserve Tweet and Profile Events

Preserve Webhook Delivery Evidence

Handle Every Delete Response

Resolve an Unknown Delete Result

Recreate Monitoring After Deletion

Account Monitor Deletion Checklist

Related Account Monitor Operations