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

url = "https://xquik.com/api/v1/webhooks"

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/webhooks', 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/webhooks"

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

}
Free - does not consume credits
curl https://xquik.com/api/v1/webhooks \
  -H "x-api-key: xq_YOUR_KEY_HERE" \
  | jq '.webhooks[] | {
    webhook_id: .id,
    url,
    event_types: .eventTypes,
    is_active: .isActive,
    delivery_status: .deliveryStatus,
    consecutive_failures: .consecutiveFailures,
    failure_hard_cap: .failureHardCap,
    created_at: .createdAt,
    update_endpoint: ("/api/v1/webhooks/" + .id),
    delete_endpoint: ("/api/v1/webhooks/" + .id),
    test_endpoint: ("/api/v1/webhooks/" + .id + "/test"),
    resume_endpoint: ("/api/v1/webhooks/" + .id + "/resume"),
    deliveries_endpoint: ("/api/v1/webhooks/" + .id + "/deliveries"),
    signing_secret_available: false
  }'

const response = await fetch("https://xquik.com/api/v1/webhooks", {
  headers: { "x-api-key": "xq_YOUR_KEY_HERE" },
});
const data = await response.json();
const webhookRows = data.webhooks.map((webhook) => ({
  webhook_id: webhook.id,
  url: webhook.url,
  event_types: webhook.eventTypes,
  is_active: webhook.isActive,
  delivery_status: webhook.deliveryStatus,
  consecutive_failures: webhook.consecutiveFailures,
  failure_hard_cap: webhook.failureHardCap,
  created_at: webhook.createdAt,
  update_endpoint: `/api/v1/webhooks/${webhook.id}`,
  delete_endpoint: `/api/v1/webhooks/${webhook.id}`,
  test_endpoint: `/api/v1/webhooks/${webhook.id}/test`,
  resume_endpoint: `/api/v1/webhooks/${webhook.id}/resume`,
  deliveries_endpoint: `/api/v1/webhooks/${webhook.id}/deliveries`,
  signing_secret_available: false,
}));

for (const row of webhookRows) {
  process.stdout.write(`${JSON.stringify(row)}\n`);
}

import json
import requests

response = requests.get(
    "https://xquik.com/api/v1/webhooks",
    headers={"x-api-key": "xq_YOUR_KEY_HERE"},
)
data = response.json()
webhook_rows = [
    {
        "webhook_id": webhook["id"],
        "url": webhook["url"],
        "event_types": webhook["eventTypes"],
        "is_active": webhook["isActive"],
        "delivery_status": webhook["deliveryStatus"],
        "consecutive_failures": webhook["consecutiveFailures"],
        "failure_hard_cap": webhook["failureHardCap"],
        "created_at": webhook["createdAt"],
        "update_endpoint": f"/api/v1/webhooks/{webhook['id']}",
        "delete_endpoint": f"/api/v1/webhooks/{webhook['id']}",
        "test_endpoint": f"/api/v1/webhooks/{webhook['id']}/test",
        "resume_endpoint": f"/api/v1/webhooks/{webhook['id']}/resume",
        "deliveries_endpoint": f"/api/v1/webhooks/{webhook['id']}/deliveries",
        "signing_secret_available": False,
    }
    for webhook in data["webhooks"]
]
for row in webhook_rows:
    print(json.dumps(row))

package main

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

type Webhook struct {
  ConsecutiveFailures int      `json:"consecutiveFailures"`
  CreatedAt           string   `json:"createdAt"`
  DeliveryStatus      string   `json:"deliveryStatus"`
  EventTypes          []string `json:"eventTypes"`
  FailureHardCap      int      `json:"failureHardCap"`
  ID                  string   `json:"id"`
  IsActive            bool     `json:"isActive"`
  URL                 string   `json:"url"`
}

type WebhookResponse struct {
  Webhooks []Webhook `json:"webhooks"`
}

type WebhookRow struct {
  WebhookID              string   `json:"webhook_id"`
  URL                    string   `json:"url"`
  EventTypes             []string `json:"event_types"`
  IsActive               bool     `json:"is_active"`
  DeliveryStatus         string   `json:"delivery_status"`
  ConsecutiveFailures    int      `json:"consecutive_failures"`
  FailureHardCap         int      `json:"failure_hard_cap"`
  CreatedAt              string   `json:"created_at"`
  UpdateEndpoint         string   `json:"update_endpoint"`
  DeleteEndpoint         string   `json:"delete_endpoint"`
  TestEndpoint           string   `json:"test_endpoint"`
  ResumeEndpoint         string   `json:"resume_endpoint"`
  DeliveriesEndpoint     string   `json:"deliveries_endpoint"`
  SigningSecretAvailable bool     `json:"signing_secret_available"`
}

func main() {
  req, err := http.NewRequest("GET", "https://xquik.com/api/v1/webhooks", 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 data WebhookResponse
  if err := json.NewDecoder(resp.Body).Decode(&data); err != nil {
    log.Fatal(err)
  }

  encoder := json.NewEncoder(os.Stdout)
  for _, webhook := range data.Webhooks {
    row := WebhookRow{
      WebhookID:              webhook.ID,
      URL:                    webhook.URL,
      EventTypes:             webhook.EventTypes,
      IsActive:               webhook.IsActive,
      DeliveryStatus:         webhook.DeliveryStatus,
      ConsecutiveFailures:    webhook.ConsecutiveFailures,
      FailureHardCap:         webhook.FailureHardCap,
      CreatedAt:              webhook.CreatedAt,
      UpdateEndpoint:         "/api/v1/webhooks/" + webhook.ID,
      DeleteEndpoint:         "/api/v1/webhooks/" + webhook.ID,
      TestEndpoint:           "/api/v1/webhooks/" + webhook.ID + "/test",
      ResumeEndpoint:         "/api/v1/webhooks/" + webhook.ID + "/resume",
      DeliveriesEndpoint:     "/api/v1/webhooks/" + webhook.ID + "/deliveries",
      SigningSecretAvailable: false,
    }
    if err := encoder.Encode(row); err != nil {
      log.Fatal(err)
    }
  }
}
These examples shape one inventory row per webhook instead of printing the full response page. Split the rows by is_active and delivery_status, then store update, delete, test, resume, and delivery-log endpoints with each receiver. List responses never include the signing secret; keep the one-time secret from Create Webhook in your secret manager.

​
Headers

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

​
Response

​
webhooks
array
List of webhook objects for your account. Returns up to 200 webhooks.
{
  "webhooks": [
    {
      "id": "15",
      "url": "https://your-server.com/webhook",
      "eventTypes": ["tweet.new", "tweet.reply"],
      "isActive": true,
      "consecutiveFailures": 0,
      "deliveryStatus": "active",
      "failureHardCap": 200,
      "createdAt": "2026-02-24T10:30:00.000Z"
    },
    {
      "id": "16",
      "url": "https://backup.example.com/xquik",
      "eventTypes": ["tweet.new"],
      "isActive": false,
      "consecutiveFailures": 200,
      "deliveryStatus": "needs_attention",
      "failureHardCap": 200,
      "createdAt": "2026-02-20T08:15:00.000Z"
    }
  ]
}
The secret is never included in list responses. It is only returned once at creation time.

​
Inventory handoff

Use this endpoint when an ops job, CRM integration, alert worker, or agent needs to reconcile which signed webhook endpoints are configured for the account.

Configuration ID

Store webhooks[].id for updates, deletes, test deliveries, and delivery history lookups.

Delivery Target

Store webhooks[].url so configuration reviews can detect stale receiver endpoints before production monitor events fail.

Event Filter

Store webhooks[].eventTypes and compare it with monitor event types before expecting tweet.new, tweet.quote, tweet.reply, or tweet.retweet.

Active State

Store webhooks[].isActive; inactive webhooks do not receive monitor events. Use deliveryStatus to distinguish paused from needs-attention receivers.

Delivery Status

Store webhooks[].deliveryStatus. Route needs_attention rows to Resume Webhook after the receiver is fixed.

Failure Counter

Store webhooks[].consecutiveFailures and webhooks[].failureHardCap for alerting before the receiver reaches the recovery gate.

Change Links

For each row, link active receivers to Update Webhook, Test Webhook, Resume Webhook, and List Deliveries. Link stale receivers to Delete Webhook.

Inactive Review

Inactive rows are configuration records, not active delivery targets. Keep their webhooks[].id so deactivation receipts and rollback plans can find the same webhook.

Delivery Audit

Use the per-webhook deliveries endpoint to store streamEventId, status, attempts, lastStatusCode, lastError, createdAt, and deliveredAt.

Event Join

Use delivery streamEventId as the {id} for Get Event. Store monitorId, monitorType, type, occurredAt, and data with the inventory audit.

Created At

Store webhooks[].createdAt for audit logs and configuration drift checks.

Signing Secret

The signing secret is not listed. Store it from Create Webhook, then verify deliveries with Signature Verification.
This endpoint supports dual authentication: API key (x-api-key header) or session cookie from the dashboard.Next steps: Create Webhook · Update Webhook · Test Webhook · Resume Webhook · List Deliveries · Get Event · Delete Webhook
Last modified on June 23, 2026