> ## Documentation Index
> Fetch the complete documentation index at: https://docs.xquik.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Update monitor

> Change event types or toggle active status for a monitor

<blockquote className="agent-llms-directive">
  For the complete documentation index, see <a href="/llms.txt">llms.txt</a>.
</blockquote>

<Callout icon="circle-check" color="#16a34a">
  **Free** - does not consume credits
</Callout>

<CodeGroup>
  ```bash cURL theme={null}
  curl -X PATCH https://xquik.com/api/v1/monitors/7 \
    -H "x-api-key: xq_YOUR_KEY_HERE" \
    -H "Content-Type: application/json" \
    -d '{
      "eventTypes": ["tweet.new", "tweet.reply"],
      "isActive": true
    }' | jq -c '{
      monitor_id: .id,
      username,
      x_user_id: .xUserId,
      event_types: .eventTypes,
      is_active: .isActive,
      created_at: .createdAt,
      next_billing_at: .nextBillingAt,
      verify_endpoint: ("/api/v1/monitors/" + .id),
      list_endpoint: "/api/v1/monitors",
      events_endpoint: ("/api/v1/events?monitorId=" + .id),
      event_detail_endpoint_pattern: "/api/v1/events/{event_id}",
      webhooks_endpoint: "/api/v1/webhooks",
      deliveries_endpoint_pattern: "/api/v1/webhooks/{webhook_id}/deliveries"
    }'
  ```

  ```javascript Node.js theme={null}
  const monitorId = "7";
  const response = await fetch(`https://xquik.com/api/v1/monitors/${monitorId}`, {
    method: "PATCH",
    headers: {
      "x-api-key": "xq_YOUR_KEY_HERE",
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      eventTypes: ["tweet.new", "tweet.reply"],
      isActive: true,
    }),
  });
  const monitor = await response.json();
  const monitorState = {
    monitor_id: monitor.id,
    username: monitor.username,
    x_user_id: monitor.xUserId,
    event_types: monitor.eventTypes,
    is_active: monitor.isActive,
    created_at: monitor.createdAt,
    next_billing_at: monitor.nextBillingAt,
    verify_endpoint: `/api/v1/monitors/${monitor.id}`,
    list_endpoint: "/api/v1/monitors",
    events_endpoint: `/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",
  };
  process.stdout.write(`${JSON.stringify(monitorState)}\n`);
  ```

  ```python Python theme={null}
  import json
  import requests

  monitor_id = "7"
  response = requests.patch(
      f"https://xquik.com/api/v1/monitors/{monitor_id}",
      headers={"x-api-key": "xq_YOUR_KEY_HERE"},
      json={
          "eventTypes": ["tweet.new", "tweet.reply"],
          "isActive": True,
      },
  )
  monitor = response.json()
  monitor_state = {
      "monitor_id": monitor["id"],
      "username": monitor["username"],
      "x_user_id": monitor["xUserId"],
      "event_types": monitor["eventTypes"],
      "is_active": monitor["isActive"],
      "created_at": monitor["createdAt"],
      "next_billing_at": monitor["nextBillingAt"],
      "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(monitor_state))
  ```

  ```go Go theme={null}
  package main

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

  type Monitor struct {
      ID            string   `json:"id"`
      Username      string   `json:"username"`
      XUserID       string   `json:"xUserId"`
      EventTypes    []string `json:"eventTypes"`
      IsActive      bool     `json:"isActive"`
      CreatedAt     string   `json:"createdAt"`
      NextBillingAt string   `json:"nextBillingAt"`
  }

  type MonitorState struct {
      DeliveriesEndpointPattern  string   `json:"deliveries_endpoint_pattern"`
      EventDetailEndpointPattern string   `json:"event_detail_endpoint_pattern"`
      EventsEndpoint             string   `json:"events_endpoint"`
      EventTypes                 []string `json:"event_types"`
      CreatedAt                  string   `json:"created_at"`
      IsActive                   bool     `json:"is_active"`
      ListEndpoint               string   `json:"list_endpoint"`
      MonitorID                  string   `json:"monitor_id"`
      NextBillingAt              string   `json:"next_billing_at"`
      Username                   string   `json:"username"`
      VerifyEndpoint             string   `json:"verify_endpoint"`
      WebhooksEndpoint           string   `json:"webhooks_endpoint"`
      XUserID                    string   `json:"x_user_id"`
  }

  func main() {
      body, _ := json.Marshal(map[string]interface{}{
          "eventTypes": []string{"tweet.new", "tweet.reply"},
          "isActive":   true,
      })

      monitorID := "7"
      req, err := http.NewRequest("PATCH", "https://xquik.com/api/v1/monitors/"+monitorID, bytes.NewReader(body))
      if err != nil {
          log.Fatal(err)
      }
      req.Header.Set("x-api-key", "xq_YOUR_KEY_HERE")
      req.Header.Set("Content-Type", "application/json")

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

      var monitor Monitor
      if err := json.NewDecoder(resp.Body).Decode(&monitor); err != nil {
          log.Fatal(err)
      }
      state := MonitorState{
          DeliveriesEndpointPattern:  "/api/v1/webhooks/{webhook_id}/deliveries",
          EventDetailEndpointPattern: "/api/v1/events/{event_id}",
          EventsEndpoint:             "/api/v1/events?monitorId=" + monitor.ID,
          EventTypes:                 monitor.EventTypes,
          CreatedAt:                  monitor.CreatedAt,
          IsActive:                   monitor.IsActive,
          ListEndpoint:               "/api/v1/monitors",
          MonitorID:                  monitor.ID,
          NextBillingAt:              monitor.NextBillingAt,
          Username:                   monitor.Username,
          VerifyEndpoint:             "/api/v1/monitors/" + monitor.ID,
          WebhooksEndpoint:           "/api/v1/webhooks",
          XUserID:                    monitor.XUserID,
      }
      if err := json.NewEncoder(os.Stdout).Encode(state); err != nil {
          log.Fatal(err)
      }
  }
  ```
</CodeGroup>

The Node.js, Python, and Go examples convert the updated account monitor into
one state row. Store `monitor_id`, `event_types`, `is_active`,
`next_billing_at`, `verify_endpoint`, `list_endpoint`, `events_endpoint`,
`event_detail_endpoint_pattern`, `webhooks_endpoint`, and
`deliveries_endpoint_pattern` before resuming alerts or webhook checks.

## Path parameters

<ParamField path="id" type="string" required>
  The unique monitor ID.
</ParamField>

## Headers

<ParamField header="x-api-key" type="string" required>
  Your API key. Session cookie authentication is also supported. Generate a key from the [dashboard](https://xquik.com/dashboard).
</ParamField>

<ParamField header="Content-Type" type="string" required>
  Must be `application/json`.
</ParamField>

## Body

At least 1 field is required.

<ParamField body="eventTypes" type="string[]">
  Updated array of event types. Must contain at least 1 valid account monitor
  type: `tweet.new`, `tweet.quote`, `tweet.reply`, `tweet.retweet`,
  `tweet.media`, `tweet.link`, `tweet.poll`, `tweet.mention`,
  `tweet.hashtag`, `tweet.longform`, `profile.avatar.changed`,
  `profile.banner.changed`, `profile.name.changed`,
  `profile.username.changed`, `profile.bio.changed`,
  `profile.location.changed`, `profile.url.changed`,
  `profile.verified.changed`, `profile.protected.changed`,
  `profile.pinned_tweet.changed`, `profile.unavailable.changed`.
</ParamField>

<ParamField body="isActive" type="boolean">
  Set to `false` to pause monitoring, or `true` to resume. Paused account
  monitors do not consume hourly monitor credits.
</ParamField>

## Update handoff

Use this endpoint when an account alert changes event scope, needs a temporary
pause, or must resume without creating a new monitor ID.

<CardGroup cols={2}>
  <Card title="Returned State" icon="clipboard-check">
    Store returned `id`, `username`, `xUserId`, `eventTypes`, `isActive`,
    `createdAt`, and `nextBillingAt` as the current account monitor
    configuration.
  </Card>

  <Card title="Inventory Sync" icon="list-checks">
    Refresh [List Monitors](/api-reference/monitors/list) after the PATCH and
    compare [Get Monitor](/api-reference/monitors/get) for the same `id` before
    updating queues, CRM records, or support notes.
  </Card>

  <Card title="Event Filter" icon="funnel">
    `eventTypes` replaces the current filter. Keep [List Webhooks](/api-reference/webhooks/list)
    subscriptions aligned with the monitor event types you expect to deliver.
  </Card>

  <Card title="Pause Monitoring" icon="circle-pause">
    `isActive: false` pauses future account checks, stored events, future webhook
    deliveries, and hourly monitor billing for this monitor.
  </Card>

  <Card title="Resume Monitoring" icon="circle-play">
    `isActive: true` resumes checks for matching future account activity. Check
    `nextBillingAt`, then run [Test Webhook](/api-reference/webhooks/test)
    before relying on production alerts.
  </Card>

  <Card title="Account Identity" icon="user-check">
    PATCH cannot change `username` or `xUserId`. Delete this monitor and create
    a new account monitor when the tracked account changes.
  </Card>

  <Card title="Downstream Join" icon="link">
    Keep using `monitorId` and `username` from
    [List Events](/api-reference/events/list) to reconcile stored events after
    the update. Use returned event IDs with [Get Event](/api-reference/events/get)
    when a workflow needs the full tweet payload.
  </Card>

  <Card title="Delivery Audit" icon="activity">
    Use [List Deliveries](/api-reference/webhooks/deliveries) for each webhook
    and join delivery `streamEventId` to event IDs. Do not use `x_event_id` as
    the delivery join key.
  </Card>
</CardGroup>

## Response

<Tabs>
  <Tab title="200 OK">
    <ResponseField name="id" type="string">Unique monitor ID.</ResponseField>
    <ResponseField name="username" type="string">Normalized X username.</ResponseField>
    <ResponseField name="xUserId" type="string">Resolved X user ID.</ResponseField>
    <ResponseField name="eventTypes" type="string[]">Updated event types.</ResponseField>
    <ResponseField name="isActive" type="boolean">Current active status after update.</ResponseField>
    <ResponseField name="createdAt" type="string">ISO 8601 creation timestamp.</ResponseField>
    <ResponseField name="nextBillingAt" type="string">Next hourly credit charge time for active monitor billing.</ResponseField>

    ```json theme={null}
    {
      "id": "7",
      "username": "elonmusk",
      "xUserId": "44196397",
      "eventTypes": ["tweet.new", "tweet.reply"],
      "isActive": true,
      "createdAt": "2026-02-24T10:30:00.000Z",
      "nextBillingAt": "2026-02-24T11:30:00.000Z"
    }
    ```
  </Tab>

  <Tab title="400 Invalid Input">
    ```json theme={null}
    { "error": "invalid_input", "message": "Empty body, invalid event types, or invalid isActive type" }
    ```

    Empty body, invalid `eventTypes` values, or invalid `isActive` type.

    ```json theme={null}
    { "error": "invalid_id", "message": "Invalid ID format." }
    ```

    The provided monitor ID is not a valid format.
  </Tab>

  <Tab title="401 Unauthenticated">
    ```json theme={null}
    { "error": "unauthenticated", "message": "Missing or invalid API key" }
    ```

    Missing or invalid API key.
  </Tab>

  <Tab title="404 Not Found">
    ```json theme={null}
    { "error": "not_found", "message": "Monitor not found" }
    ```

    No monitor exists with this ID, or it belongs to a different account.
  </Tab>

  <Tab title="429 Rate Limited">
    ```json theme={null}
    { "error": "rate_limit_exceeded", "message": "Too many requests. Try again later.", "retryAfter": 60 }
    ```

    Too many requests. Wait for the `Retry-After` header before retrying.
  </Tab>
</Tabs>

<Info>
  `isActive: false` pauses future checks, stored events, webhook deliveries, and
  hourly monitor billing for this monitor. `isActive: true` resumes future
  checks with the returned `eventTypes`.
</Info>

<Note>
  **Related:** [List Monitors](/api-reference/monitors/list) to refresh inventory, [Get Monitor](/api-reference/monitors/get) to verify this monitor, [List Events](/api-reference/events/list) to audit stored events, [Get Event](/api-reference/events/get) to inspect one event, [List Webhooks](/api-reference/webhooks/list) to compare subscriptions, or [List Deliveries](/api-reference/webhooks/deliveries) to audit webhook delivery status.
</Note>