Xquik

https://github.com/xquik-dev/xquik-docs
Admin
Xquik is an X (Twitter) real-time data platform for extracting followers, running giveaway draws,...
Tokens:1,026,724
Snippets:7,909
Trust Score:7.5
License:MIT
Update:3 weeks ago
Show doc for...
Tokens:
Raw
### GET /styles client examples (cURL, Node.js, Python, Go)

Source: https://github.com/xquik-dev/xquik-docs/blob/main/api-reference/styles/list.mdx

Client examples for calling the GET /styles endpoint in cURL, Node.js, Python, and Go. All use the x-api-key header with a placeholder key and parse the JSON response.

```bash
curl -X GET https://xquik.com/api/v1/styles \
  -H "x-api-key: xq_YOUR_KEY_HERE" | jq
```

```javascript
const response = await fetch("https://xquik.com/api/v1/styles", {
  method: "GET",
  headers: {
    "x-api-key": "xq_YOUR_KEY_HERE",
  },
});
const data = await response.json();
```

```python
import requests

response = requests.get(
    "https://xquik.com/api/v1/styles",
    headers={"x-api-key": "xq_YOUR_KEY_HERE"},
)
data = response.json()
```

```go
package main

import (
    "encoding/json"
    "fmt"
    "net/http"
)

func main() {
    req, err := http.NewRequest("GET", "https://xquik.com/api/v1/styles", nil)
    if err != nil {
        panic(err)
    }
    req.Header.Set("x-api-key", "xq_YOUR_KEY_HERE")

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

    var data map[string]interface{}
    if err := json.NewDecoder(resp.Body).Decode(&data); err != nil {
        panic(err)
    }
    fmt.Println(data)
}
```

--------------------------------

### GET /trends

Source: https://github.com/xquik-dev/xquik-docs/blob/main/api-reference/trends/list.mdx

Documentation for the GET /trends endpoint, including parameters, request example, and response structure.

```APIDOC
## GET /trends

### Description
Retrieves ranked Twitter trends for a specified WOEID. This endpoint is a top-level alias for ranked WOEID topics and returns a `total` field.

### Method
GET

### Endpoint
https://xquik.com/api/v1/trends

### Parameters
#### Query Parameters
- **woeid** (integer) - Required - The WOEID (Where On Earth ID) of the region for which to retrieve trends.
- **count** (integer) - Optional - The number of trends to return.

### Request Example
```
curl "https://xquik.com/api/v1/trends?woeid=23424977&count=10" \
  -H "x-api-key: xq_your_api_key_here" | jq
```

### Response
#### Success Response (200)
- **trends** (array) - List of trend objects.
  - **name** (string) - The name of the trend.
  - **rank** (integer, optional) - The rank of the trend.
  - **description** (string, optional) - Description of the trend.
  - **query** (string, optional) - The search query for the trend.
- **total** (integer) - Total number of trends returned.
- **woeid** (integer) - The WOEID of the region.

#### Response Example
```json
{
  "trends": [
    {
      "name": "#ExampleTrend",
      "rank": 1,
      "description": "Example description",
      "query": "#ExampleTrend"
    }
  ],
  "total": 1,
  "woeid": 23424977
}
```
```

--------------------------------

### Set up compatibility sandbox and register prefect_xquik block

Source: https://github.com/xquik-dev/xquik-docs/blob/main/guides/prefect.mdx

Set up a sandbox virtual environment, install the latest Prefect and prefect-xquik, start the Prefect server, then configure the API URL and register the prefect_xquik block. Run the server before registering the block.

```bash
python -m venv .venv-prefect-compat
source .venv-prefect-compat/bin/activate
python -m pip install -U prefect prefect-xquik
prefect server start
```

```bash
source .venv-prefect-compat/bin/activate
prefect config set PREFECT_API_URL="http://127.0.0.1:4200/api"
prefect block register -m prefect_xquik
```

--------------------------------

### Get Tweet - Successful Response Example

Source: https://github.com/xquik-dev/xquik-docs/blob/main/api-reference/x/get-tweet.mdx

Example JSON response for a successful Get Tweet request. Shows the tweet object with fields like id, text, entities, quoted_tweet, and media, as well as the author object.

```json
{
  "tweet": {
    "id": "1893456789012345678",
    "text": "Introducing our new extraction API. Ship faster.",
    "createdAt": "2026-02-24T14:30:00.000Z",
    "isNoteTweet": false,
    "isReply": false,
    "isQuoteStatus": true,
    "conversationId": "1893456789012345678",
    "source": "Twitter Web App",
    "contentDisclosure": {
      "advertising": { "isPaidPromotion": true },
      "aiGenerated": {
        "detectionSource": "UserDeclared",
        "hasAiGeneratedMedia": true
      }
    },
    "entities": {
      "urls": [
        {
          "display_url": "xquik.com/blog/extracti...",
          "expanded_url": "https://xquik.com/blog/extraction-api",
          "url": "https://t.co/abc123"
        }
      ],
      "hashtags": [],
      "user_mentions": []
    },
    "quoted_tweet": {
      "id": "1893000000000000000",
      "text": "What API tools are you shipping this week?",
      "author": {
        "id": "111222333",
        "username": "devtools"
      }
    },
    "retweetCount": 320,
    "replyCount": 85,
    "likeCount": 1400,
    "quoteCount": 45,
    "viewCount": 250000,
    "bookmarkCount": 210,
    "media": [
      {
        "mediaUrl": "https://pbs.twimg.com/media/example.jpg",
        "type": "photo",
        "url": "https://t.co/abc123"
      }
    ]
  },
  "author": {
    "id": "987654321",
    "username": "username",
    "followers": 10000,
    "verified": true,
    "profilePicture": "https://pbs.twimg.com/profile_images/xquik/photo.jpg"
  }
}
```

--------------------------------

### Run Mintlify dev server

Source: https://github.com/xquik-dev/xquik-docs/blob/main/README.md

Start the local development server for visual previewing. Use only when necessary; otherwise rely on static checks.

```bash
bun run --bun --no-install mint dev
```

--------------------------------

### Install Go SDK

Source: https://github.com/xquik-dev/xquik-docs/blob/main/sdks/go.mdx

Installs the Xquik Go SDK package.

```bash
go get github.com/Xquik-dev/x-twitter-scraper-go
```

--------------------------------

### Set up a webhook (cURL, Node.js, Python, Go)

Source: https://github.com/xquik-dev/xquik-docs/blob/main/x-api-quickstart.mdx

Creates a webhook to receive signed monitor events. The cURL example posts to /api/v1/webhooks. The Node.js example uses fetch and extracts the webhook secret, warning not to print it. The Python example uses requests and raises an error if the secret is missing. The Go example is not shown in the source.

```bash
curl -s -X POST https://xquik.com/api/v1/webhooks \
  -H "x-api-key: xq_your_api_key_here" \
  -H "Content-Type: application/json" \
  -d '{"url": "https://your-server.com/webhook", "eventTypes": ["tweet.new"]}' | jq
```

```javascript
const response = await fetch("https://xquik.com/api/v1/webhooks", {
  method: "POST",
  headers: {
    "x-api-key": "xq_your_api_key_here",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    url: "https://your-server.com/webhook",
    eventTypes: ["tweet.new"],
  }),
});
const webhook = await response.json();
const webhookSecret = webhook.secret;
if (!webhookSecret) throw new Error("missing webhook secret");
process.stdout.write(`Webhook ${webhook.id} ready\n`);
// Store webhookSecret in your secret manager; do not print it.
```

```python
import requests

response = requests.post(
    "https://xquik.com/api/v1/webhooks",
    headers={"x-api-key": "xq_your_api_key_here"},
    json={
        "url": "https://your-server.com/webhook",
        "eventTypes": ["tweet.new"],
    },
)
webhook = response.json()
webhook_secret = webhook["secret"]
if not webhook_secret:
    raise RuntimeError("missing webhook secret")
print(f"Webhook {webhook['id']} ready")
# Store webhook_secret in your secret manager; do not print it.
```

--------------------------------

### GET /api/v1/x/tweets/{tweet_id}/retweeters

Source: https://github.com/xquik-dev/xquik-docs/blob/main/api-reference/x/retweeters.mdx

Documentation for the GET retweeters endpoint, including parameters, request example, and response structure.

```APIDOC
## [GET] /api/v1/x/tweets/{tweet_id}/retweeters

### Description
Retrieves a paginated list of users who retweeted a specific tweet. Supports an optional query parameter to include the retweet timestamp for each user.

### Method
GET

### Endpoint
`https://xquik.com/api/v1/x/tweets/{tweet_id}/retweeters`

### Parameters
#### Path Parameters
- **tweet_id** (string) - Required - The ID of the tweet for which to retrieve retweeters.

#### Query Parameters
- **includeRetweetTimestamp** (boolean) - Optional - When set to `true`, the response includes each user's `retweetedAt` timestamp. Defaults to `false`.

### Request Example
```bash
curl -G https://xquik.com/api/v1/x/tweets/1893456789012345678/retweeters \
  --data-urlencode "includeRetweetTimestamp=true" \
  -H "x-api-key: xq_your_api_key_here"
```

### Response
#### Success Response (200)
- **users** (array) - List of user objects who retweeted the tweet.
  - **id** (string) - The user's ID.
  - **username** (string) - The user's username.
  - **name** (string) - The user's display name.
  - **followers** (number) - The user's follower count.
  - **following** (number) - The user's following count.
  - **verified** (boolean) - Whether the user is verified.
  - **verifiedType** (string) - The type of verification, if any.
  - **profilePicture** (string) - URL of the user's profile image.
  - **retweetedAt** (string) - UTC ISO 8601 timestamp of the retweet, or `null` if not available. Only present when `includeRetweetTimestamp=true`.
  - **createdAt** (string) - The account creation date.
- **next_cursor** (string) - Cursor for the next page of results.
- **has_next_page** (boolean) - Indicates whether there are more pages.

#### Response Example
```json
{
  "users": [
    {
      "id": "123456789",
      "username": "user123",
      "name": "User Name",
      "followers": 1000,
      "following": 200,
      "verified": false,
      "verifiedType": null,
      "profilePicture": "https://pbs.twimg.com/profile_images/...",
      "retweetedAt": "2025-03-01T12:00:00Z",
      "createdAt": "2020-01-01T00:00:00Z"
    }
  ],
  "next_cursor": "...",
  "has_next_page": false
}
```
```

--------------------------------

### Install mppx and viem

Source: https://github.com/xquik-dev/xquik-docs/blob/main/mpp/quickstart.mdx

Install the mppx SDK and viem for wallet management. The mppx package provides both client and server utilities; you only need the client.

```bash
npm i mppx viem
```

--------------------------------

### GET /api/v1/x/tweets/{tweetId}/replies

Source: https://github.com/xquik-dev/xquik-docs/blob/main/api-reference/x/tweet-replies.mdx

Documentation for the GET /api/v1/x/tweets/{tweetId}/replies endpoint, including parameters, request examples, and response structure.

```APIDOC
## GET /api/v1/x/tweets/{tweetId}/replies

### Description
Retrieves replies to a specific tweet. Supports pagination via cursor, time-bounding via sinceTime and untilTime, and advanced nested-reply diagnostics via mode and limit parameters.

### Method
GET

### Endpoint
/api/v1/x/tweets/{tweetId}/replies

### Parameters
#### Path Parameters
- **tweetId** (string) - Required - The ID of the tweet whose replies are being retrieved.

#### Query Parameters
- **cursor** (string) - Optional - The pagination cursor from the previous page's `next_cursor` to resume fetching replies.
- **sinceTime** (integer) - Optional - Unix timestamp (seconds) to bound the start of the reply retrieval window.
- **untilTime** (integer) - Optional - Unix timestamp (seconds) to bound the end of the reply retrieval window.
- **mode** (string) - Optional - Set to `complete` to request advanced nested-reply diagnostics.
- **limit** (integer) - Optional - Maximum number of replies to return (e.g., 25000).

### Request Example
```bash
curl "https://xquik.com/api/v1/x/tweets/1893456789012345678/replies" \
  -H "x-api-key: xq_your_api_key_here" | jq
```

### Response
#### Success Response (200)
- **tweets** (array) - List of reply objects.
- **next_cursor** (string) - Cursor for the next page of results.
- **has_next_page** (boolean) - Indicates whether more pages are available.

#### Response Example
```json
{
  "tweets": [
    {
      "id": "string",
      "text": "string",
      "author": {
        "id": "string",
        "username": "string"
      },
      "createdAt": "string",
      "inReplyToId": "string",
      "conversationId": "string",
      "likeCount": 0,
      "media": [
        {
          "mediaUrl": "string"
        }
      ]
    }
  ],
  "next_cursor": "string",
  "has_next_page": true
}
```

### Error Handling
- Non-2xx responses return a JSON error object; check `response.ok` in client code and handle accordingly.
```

--------------------------------

### GET /api/v1/x/tweets/{id}/retweeters

Source: https://github.com/xquik-dev/xquik-docs/blob/main/api-reference/x/retweeters.mdx

Documentation for the GET /api/v1/x/tweets/{id}/retweeters endpoint, including parameters, response examples, and error handling.

```APIDOC
## GET /api/v1/x/tweets/{id}/retweeters

### Description
Returns the list of users who retweeted a specified public tweet. Each result includes user profile information such as ID, username, display name, follower counts, and verification fields. Supports pagination via a cursor for large result sets.

### Method
GET

### Endpoint
https://xquik.com/api/v1/x/tweets/{id}/retweeters

### Parameters
#### Path Parameters
- **id** (string) - Required - The ID of the tweet to retrieve retweeters for.

#### Query Parameters
- **cursor** (string) - Optional - Pagination cursor for fetching the next page of results.

### Request Example
```bash
curl "https://xquik.com/api/v1/x/tweets/1893456789012345678/retweeters" \
  -H "x-api-key: xq_your_api_key_here" | jq
```

### Response
#### Success Response (200)
- **users** (array) - List of user objects representing retweeters.
- **has_next_page** (boolean) - Indicates whether there are more pages of results.
- **next_cursor** (string) - Cursor for the next page, empty if no more pages.

#### Response Example
```json
{
  "users": [],
  "has_next_page": false,
  "next_cursor": ""
}
```

### Error Handling
- **400** - Invalid input. Check the request body.
- **401** - Authentication required.
- **402** - Insufficient credits. Top up or subscribe to continue.
- **404** - Tweet not found. Check the tweet ID.
- **424** - X data source temporarily unavailable. Try again later.
- **429** - Too many requests. Try again later.
- **502** - X data source temporarily unavailable. Try again later.
- **503** - Xquik is busy right now. Retry shortly.
```

--------------------------------

### Install dependencies and run checks

Source: https://github.com/xquik-dev/xquik-docs/blob/main/README.md

Install pinned dependencies and run all static checks. Requires Bun, Go, Gitleaks, shfmt, and uv. Missing product source or parent coverage baselines will fail validation.

```bash
bunx --bun npm@12.0.1 ci --ignore-scripts
bun run check:all
```

--------------------------------

### GET /extractions request examples (cURL, Node.js, Python, Go)

Source: https://github.com/xquik-dev/xquik-docs/blob/main/api-reference/extractions/twitter-scraping-job-history.mdx

Example requests for the GET /extractions endpoint, shown in cURL, Node.js, Python, and Go. All use the x-api-key header with a placeholder key and query parameters limit=20 and toolType=reply_extractor. The endpoint is free and does not consume credits.

```bash
curl -X GET "https://xquik.com/api/v1/extractions?limit=20&toolType=reply_extractor" \
  -H "x-api-key: xq_YOUR_KEY_HERE" | jq
```

```javascript
const params = new URLSearchParams({
  limit: "20",
  toolType: "reply_extractor",
});

const response = await fetch(`https://xquik.com/api/v1/extractions?${params}`, {
  method: "GET",
  headers: {
    "x-api-key": "xq_YOUR_KEY_HERE",
  },
});
const data = await response.json();
```

```python
import requests

response = requests.get(
    "https://xquik.com/api/v1/extractions",
    headers={"x-api-key": "xq_YOUR_KEY_HERE"},
    params={
        "limit": 20,
        "toolType": "reply_extractor",
    },
)
data = response.json()
```

```go
package main

import (
    "encoding/json"
    "fmt"
    "net/http"
)

func main() {
    req, err := http.NewRequest("GET", "https://xquik.com/api/v1/extractions?limit=20&toolType=reply_extractor", nil)
    if err != nil {
        panic(err)
    }
    req.Header.Set("x-api-key", "xq_YOUR_KEY_HERE")

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

    var data map[string]interface{}
    if err := json.NewDecoder(resp.Body).Decode(&data); err != nil {
        panic(err)
    }
    fmt.Println(data)
}
```

--------------------------------

### Top up credits with Go

Source: https://github.com/xquik-dev/xquik-docs/blob/main/api-reference/credits/topup.mdx

Use this Go example to create a hosted checkout. It constructs a POST request with the API key and dollar amount, then decodes and prints the JSON response.

```go
package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "net/http"
)

func main() {
    body, _ := json.Marshal(map[string]interface{}{
        "dollars": 10,
    })

    req, err := http.NewRequest("POST", "https://xquik.com/api/v1/credits/topup", bytes.NewReader(body))
    if err != nil {
        panic(err)
    }
    req.Header.Set("x-api-key", "xq_your_api_key_here")
    req.Header.Set("Content-Type", "application/json")

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

    var data map[string]interface{}
    if err := json.NewDecoder(resp.Body).Decode(&data); err != nil {
        panic(err)
    }
    fmt.Println(data)
}
```

--------------------------------

### GET /api-keys response examples (200, 401, 429)

Source: https://github.com/xquik-dev/xquik-docs/blob/main/api-reference/api-keys/list.mdx

Example responses for the GET /api-keys endpoint. The 200 response returns an empty keys array; the 401 response indicates missing authentication; the 429 response indicates rate limiting with a retryAfter value in seconds.

```json
{
  "keys": []
}
```

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

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

--------------------------------

### POST /subscribe request examples (cURL, Node.js, Python, Go)

Source: https://github.com/xquik-dev/xquik-docs/blob/main/api-reference/account/subscription-checkout.mdx

Example requests to create a subscription checkout or billing portal URL. The endpoint is free and does not consume credits. The response contains a URL to redirect the user to. The cURL example pipes the response through jq for pretty printing.

```bash
curl -X POST https://xquik.com/api/v1/subscribe \
  -H "x-api-key: xq_YOUR_KEY_HERE" | jq
```

```javascript
const response = await fetch("https://xquik.com/api/v1/subscribe", {
  method: "POST",
  headers: {
    "x-api-key": "xq_YOUR_KEY_HERE",
  },
});
const data = await response.json();
// Redirect user to data.url
```

```python
import requests

response = requests.post(
    "https://xquik.com/api/v1/subscribe",
    headers={"x-api-key": "xq_YOUR_KEY_HERE"},
)
data = response.json()
# Redirect user to data["url"]
```

```go
package main

import (
    "encoding/json"
    "fmt"
    "net/http"
)

func main() {
    req, err := http.NewRequest("POST", "https://xquik.com/api/v1/subscribe", nil)
    if err != nil {
        panic(err)
    }
    req.Header.Set("x-api-key", "xq_YOUR_KEY_HERE")

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

    var data map[string]interface{}
    if err := json.NewDecoder(resp.Body).Decode(&data); err != nil {
        panic(err)
    }
    fmt.Println(data)
}
```

--------------------------------

### GET /api/v1/x/users/{userIdOrUsername}/tweets

Source: https://github.com/xquik-dev/xquik-docs/blob/main/api-reference/x/user-tweets.mdx

Documentation for the GET /api/v1/x/users/{userIdOrUsername}/tweets endpoint, including parameters, request examples, response structure, and pagination details.

```APIDOC
## GET /api/v1/x/users/{userIdOrUsername}/tweets

### Description
Retrieves the profile timeline of tweets for a specified X (Twitter) user, identified by either username or numeric user ID. Supports pagination, including replies, and including parent tweet context.

### Method
GET

### Endpoint
`https://xquik.com/api/v1/x/users/{userIdOrUsername}/tweets`

### Parameters
#### Path Parameters
- **userIdOrUsername** (string) - Required - The username (e.g., `elonmusk`) or numeric user ID (e.g., `44196397`) of the user whose tweets are to be retrieved.

#### Query Parameters
- **includeReplies** (boolean) - Optional - When set to `true`, includes replies in the timeline.
- **includeParentTweet** (boolean) - Optional - When set to `true`, includes the parent tweet context for replies.
- **cursor** (string) - Optional - Pagination cursor obtained from the `next_cursor` field in the previous response. Used to fetch the next page of results.

### Request Example
```bash
curl -G https://xquik.com/api/v1/x/users/elonmusk/tweets \
  --data-urlencode "includeReplies=true" \
  --data-urlencode "includeParentTweet=true" \
  -H "x-api-key: xq_your_api_key_here" | jq
```

### Response
#### Success Response (200)
- **tweets** (array) - List of tweet objects.
- **next_cursor** (string) - Cursor for the next page of results. Empty string if no more pages.
- **has_next_page** (boolean) - Indicates whether there is a next page.

Each tweet object contains:
- **id** (string) - Tweet ID.
- **text** (string) - Tweet text content.
- **author** (object) - Author information with fields: `id`, `username`, `name`, `followers`, `verified`, `profilePicture`.
- **createdAt** (string) - Creation timestamp.
- **isReply** (boolean) - Whether the tweet is a reply.
- **inReplyToId** (string) - ID of the parent tweet if it is a reply.
- **likeCount** (number) - Number of likes.
- **replyCount** (number) - Number of replies.
- **retweetCount** (number) - Number of retweets.
- **quoteCount** (number) - Number of quotes.
- **viewCount** (number) - Number of views.
- **media** (array) - List of media objects, each with a `mediaUrl` field.

#### Response Example
```json
{
  "tweets": [
    {
      "id": "123456789",
      "text": "Hello world!",
      "author": {
        "id": "44196397",
        "username": "elonmusk",
        "name": "Elon Musk",
        "followers": 150000000,
        "verified": true,
        "profilePicture": "https://pbs.twimg.com/profile_images/..."
      },
      "createdAt": "2023-01-01T00:00:00.000Z",
      "isReply": false,
      "inReplyToId": null,
      "likeCount": 1000,
      "replyCount": 200,
      "retweetCount": 300,
      "quoteCount": 50,
      "viewCount": 10000,
      "media": [
        {
          "mediaUrl": "https://pbs.twimg.com/media/..."
        }
      ]
    }
  ],
  "next_cursor": "abc123",
  "has_next_page": true
}
```

### Authentication
Requires an API key passed in the `x-api-key` header.

### Error Handling
If the response is not OK (status code not 2xx), the response body contains an error object. The client should check `response.ok` and throw an error with the JSON stringified body.
```

--------------------------------

### Make your first request - cURL, Node.js, Python, Go

Source: https://github.com/xquik-dev/xquik-docs/blob/main/x-api-quickstart.mdx

Fetch account info with GET /account to verify authentication and credits. Uses the x-api-key header. The response is printed as JSON.

```bash
curl -s https://xquik.com/api/v1/account \
  -H "x-api-key: xq_your_api_key_here" | jq
```

```javascript
const response = await fetch("https://xquik.com/api/v1/account", {
  headers: { "x-api-key": "xq_your_api_key_here" },
});
const account = await response.json();
process.stdout.write(`${JSON.stringify(account, null, 2)}\n`);
```

```python
import requests

response = requests.get(
    "https://xquik.com/api/v1/account",
    headers={"x-api-key": "xq_your_api_key_here"},
)
print(response.json())
```

```go
package main

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

func main() {
    req, _ := http.NewRequest("GET", "https://xquik.com/api/v1/account", nil)
    req.Header.Set("x-api-key", "xq_your_api_key_here")

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

    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))
}
```

--------------------------------

### GET /x/communities/{id}/tweets response examples

Source: https://github.com/xquik-dev/xquik-docs/blob/main/api-reference/x/community-tweets.mdx

Response examples for the GET /x/communities/{id}/tweets endpoint. The 200 response returns an empty tweets array with pagination fields; error responses include an error code and message, with 429 adding a retryAfter value of 60 seconds.

```json
{
  "tweets": [],
  "has_next_page": false,
  "next_cursor": ""
}
```

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

```json
{
  "error": "unauthenticated",
  "message": "Authentication required."
}
```

```json
{
  "error": "insufficient_credits",
  "message": "Insufficient credits. Top up or subscribe to continue."
}
```

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

```json
{
  "error": "x_api_unavailable",
  "message": "X data source temporarily unavailable. Try again later."
}
```

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

```json
{
  "error": "x_api_unavailable",
  "message": "X data source temporarily unavailable. Try again later."
}
```

```json
{
  "error": "x_api_unavailable",
  "message": "Xquik is busy right now. Retry shortly."
}
```

--------------------------------

### Start your local server

Source: https://github.com/xquik-dev/xquik-docs/blob/main/guides/twitter-webhook-testing.mdx

Run your webhook handler on a local port such as :3000. The example shows commands for Node.js, Python, and Go.

```bash
node server.js
# or: python app.py
# or: go run main.go
```

--------------------------------

### Check top-up status with cURL, Node.js, Python, and Go

Source: https://github.com/xquik-dev/xquik-docs/blob/main/api-reference/credits/topup-status.mdx

Client examples for checking the top-up payment status using the GET /credits/topup/status endpoint. Each example sends a GET request with the session_id query parameter and the x-api-key header, then prints the JSON response. The endpoint is free and does not consume credits.

```bash
curl "https://xquik.com/api/v1/credits/topup/status?session_id=checkout_session_id" \
  -H "x-api-key: xq_YOUR_KEY_HERE" | jq
```

```javascript
const sessionId = "checkout_session_id";
const response = await fetch(
  `https://xquik.com/api/v1/credits/topup/status?session_id=${encodeURIComponent(sessionId)}`,
  { headers: { "x-api-key": "xq_YOUR_KEY_HERE" } },
);
const data = await response.json();
console.log(data);
```

```python
import requests

response = requests.get(
    "https://xquik.com/api/v1/credits/topup/status",
    headers={"x-api-key": "xq_YOUR_KEY_HERE"},
    params={"session_id": "checkout_session_id"},
)
data = response.json()
print(data)
```

```go
package main

import (
    "encoding/json"
    "fmt"
    "net/http"
    "net/url"
)

func main() {
    endpoint, err := url.Parse("https://xquik.com/api/v1/credits/topup/status")
    if err != nil {
        panic(err)
    }
    query := endpoint.Query()
    query.Set("session_id", "checkout_session_id")
    endpoint.RawQuery = query.Encode()

    req, err := http.NewRequest("GET", endpoint.String(), nil)
    if err != nil {
        panic(err)
    }
    req.Header.Set("x-api-key", "xq_YOUR_KEY_HERE")

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

    var data map[string]interface{}
    if err := json.NewDecoder(resp.Body).Decode(&data); err != nil {
        panic(err)
    }
    fmt.Println(data)
}
```

--------------------------------

### GET /x/tweets/search

Source: https://github.com/xquik-dev/xquik-docs/blob/main/sdks/typescript.mdx

This snippet documents the GET /x/tweets/search endpoint as exposed through the TypeScript SDK method client.x.tweets.search. It includes the query parameters, request example, and response structure.

```APIDOC
## [GET] /x/tweets/search

### Description
Searches for tweets matching a query and returns paginated results. This endpoint is called through the SDK method `client.x.tweets.search` and returns a page object containing tweets and pagination information.

### Method
GET

### Endpoint
/x/tweets/search

### Parameters
#### Query Parameters
- **q** (string) - Required - The X search query with keywords, handles, hashtags, or operators.
- **limit** (integer) - Optional - Upper bound for a bounded pull, from 1 to 200.
- **cursor** (string) - Optional - Opaque cursor from `page.next_cursor` to request the next page.
- **sinceTime** (string) - Optional - Inclusive ISO bound for filtering tweets after this time.
- **untilTime** (string) - Optional - Exclusive ISO bound for filtering tweets before this time.
- **queryType** (string) - Optional - Use `Latest` for chronological results or `Top` for engagement-ranked results.

### Request Example
```json
{
  "q": "from:username webhook OR SDK",
  "queryType": "Latest",
  "cursor": null
}
```

### Response
#### Success Response (200)
- **tweets** (array) - List of tweet objects.
- **next_cursor** (string) - Opaque cursor for the next page.
- **has_next_page** (boolean) - Indicates if there are more pages.

#### Response Example
```json
{
  "tweets": [
    {
      "id": "1234567890",
      "text": "Example tweet text",
      "author": {
        "id": "user123",
        "username": "username",
        "name": "User Name"
      },
      "createdAt": "2023-01-01T00:00:00Z",
      "likeCount": 10,
      "replyCount": 2,
      "retweetCount": 5,
      "quoteCount": 1,
      "viewCount": 100,
      "bookmarkCount": 3,
      "isNoteTweet": false
    }
  ],
  "next_cursor": "opaque_cursor_value",
  "has_next_page": true
}
```
```

--------------------------------

### Go: List keyword monitors and build inventory rows

Source: https://github.com/xquik-dev/xquik-docs/blob/main/api-reference/monitors/list-keywords.mdx

Uses net/http to GET https://xquik.com/api/v1/monitors/keywords with an x-api-key header, decodes the JSON response into a KeywordMonitorListResponse, and encodes each KeywordMonitorRow to stdout. Replace xq_YOUR_KEY_HERE with your actual API key.

```go
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 KeywordMonitorListResponse struct {
    Monitors []KeywordMonitor `json:"monitors"`
    Total    int              `json:"total"`
}

type KeywordMonitorRow 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"`
    EventsEndpoint             string   `json:"events_endpoint"`
    EventDetailEndpointPattern string   `json:"event_detail_endpoint_pattern"`
    VerifyEndpoint             string   `json:"verify_endpoint"`
    UpdateEndpoint             string   `json:"update_endpoint"`
    DeleteEndpoint             string   `json:"delete_endpoint"`
    WebhooksEndpoint           string   `json:"webhooks_endpoint"`
    DeliveriesEndpointPattern  string   `json:"deliveries_endpoint_pattern"`
}

func main() {
    req, err := http.NewRequest("GET", "https://xquik.com/api/v1/monitors/keywords", 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 payload KeywordMonitorListResponse
    if err := json.NewDecoder(resp.Body).Decode(&payload); err != nil {
        log.Fatal(err)
    }
    encoder := json.NewEncoder(os.Stdout)
    for _, monitor := range payload.Monitors {
        row := KeywordMonitorRow{
            KeywordMonitorID:           monitor.ID,
            Query:                      monitor.Query,
            EventTypes:                 monitor.EventTypes,
            IsActive:                   monitor.IsActive,
            CreatedAt:                  monitor.CreatedAt,
            NextBillingAt:              monitor.NextBillingAt,
            EventsEndpoint:             "/api/v1/events?keywordMonitorId=" + monitor.ID,
            EventDetailEndpointPattern: "/api/v1/events/{event_id}",
            VerifyEndpoint:             "/api/v1/monitors/keywords/" + monitor.ID,
            UpdateEndpoint:             "/api/v1/monitors/keywords/" + monitor.ID,
            DeleteEndpoint:             "/api/v1/monitors/keywords/" + monitor.ID,
            WebhooksEndpoint:           "/api/v1/webhooks",
            DeliveriesEndpointPattern:  "/api/v1/webhooks/{webhook_id}/deliveries",
        }
        if err := encoder.Encode(row); err != nil {
            log.Fatal(err)
        }
    }
}
```

--------------------------------

### GET /api/v1/x/tweets/{tweetId}/thread

Source: https://github.com/xquik-dev/xquik-docs/blob/main/api-reference/x/tweet-thread.mdx

This snippet documents the GET endpoint for retrieving a tweet thread. It includes the endpoint path, parameters, request example, and response structure.

```APIDOC
## GET /api/v1/x/tweets/{tweetId}/thread

### Description
Retrieves the thread of tweets associated with a given tweet ID. The endpoint supports pagination via a cursor parameter and returns a list of tweets in the thread along with pagination metadata.

### Method
GET

### Endpoint
`https://xquik.com/api/v1/x/tweets/{tweetId}/thread`

### Parameters
#### Path Parameters
- **tweetId** (string) - Required - The ID of the source tweet whose thread is to be retrieved.

#### Query Parameters
- **cursor** (string) - Optional - Pagination cursor for fetching the next page of results. If not provided, the first page is returned.

### Request Example
```
GET https://xquik.com/api/v1/x/tweets/1893456789012345678/thread?cursor=abc123
Headers: { "x-api-key": "xq_your_api_key_here" }
```

### Response
#### Success Response (200)
- **tweets** (array) - List of tweet objects in the thread.
  - **id** (string) - The ID of the tweet.
  - **text** (string) - The text content of the tweet.
  - **author** (object) - Author information.
    - **id** (string) - Author's user ID.
    - **username** (string) - Author's username.
    - **name** (string) - Author's display name.
    - **followers** (number) - Author's follower count.
    - **verified** (boolean) - Whether the author is verified.
    - **profilePicture** (string) - URL of the author's profile picture.
  - **createdAt** (string) - Timestamp of tweet creation.
  - **conversationId** (string) - The conversation ID.
  - **inReplyToId** (string) - The ID of the tweet this tweet replies to.
  - **media** (array) - List of media objects.
    - **mediaUrl** (string) - URL of the media item.
- **has_next_page** (boolean) - Indicates whether there are more pages.
- **next_cursor** (string) - Cursor for the next page, if available.

#### Response Example
```json
{
  "tweets": [
    {
      "id": "1893456789012345678",
      "text": "First tweet in thread",
      "author": {
        "id": "123",
        "username": "user",
        "name": "User Name",
        "followers": 1000,
        "verified": false,
        "profilePicture": "https://example.com/avatar.jpg"
      },
      "createdAt": "2025-01-01T00:00:00Z",
      "conversationId": "conv123",
      "inReplyToId": null,
      "media": []
    }
  ],
  "has_next_page": false,
  "next_cursor": null
}
```
```

--------------------------------

### Clone and verify the repository with bun run check:all

Source: https://github.com/xquik-dev/xquik-docs/blob/main/guides/open-source-assurance.mdx

Clone the repository, install dependencies without lifecycle scripts, install licenses, and run all verification checks. Run these commands against a reviewed commit; a passing local build does not prove the hosted platform uses that commit.

```bash
git clone https://github.com/Xquik-dev/xquik-docs.git
cd xquik-docs
bun run install:frozen
bun run install:licenses
bun run check:all
```

--------------------------------

### GET /x/communities/{id}/moderators response examples

Source: https://github.com/xquik-dev/xquik-docs/blob/main/api-reference/x/community-moderators.mdx

Response examples for the GET /x/communities/{id}/moderators endpoint. The 200 response returns a list of moderator users with pagination fields. Error responses include an error code and message; the 429 response also includes a retryAfter value in seconds.

```json
{
  "users": [],
  "has_next_page": false,
  "next_cursor": ""
}
```

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

```json
{
  "error": "unauthenticated",
  "message": "Authentication required."
}
```

```json
{
  "error": "insufficient_credits",
  "message": "Insufficient credits. Top up or subscribe to continue."
}
```

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

```json
{
  "error": "x_api_unavailable",
  "message": "X data source temporarily unavailable. Try again later."
}
```

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

```json
{
  "error": "x_api_unavailable",
  "message": "X data source temporarily unavailable. Try again later."
}
```

```json
{
  "error": "x_api_unavailable",
  "message": "Xquik is busy right now. Retry shortly."
}
```

--------------------------------

### Create a monitor (cURL, Node.js, Python, Go)

Source: https://github.com/xquik-dev/xquik-docs/blob/main/x-api-quickstart.mdx

Creates a monitor for an X account. The cURL example uses POST to /api/v1/monitors with username and eventTypes. The Node.js example uses fetch and prints the response. The Python example uses requests and prints the JSON. The Go example uses net/http and prints the response body.

```bash
curl -s -X POST https://xquik.com/api/v1/monitors \
  -H "x-api-key: xq_your_api_key_here" \
  -H "Content-Type: application/json" \
  -d '{"username": "elonmusk", "eventTypes": ["tweet.new", "tweet.reply"]}' | jq
```

```javascript
const response = await fetch("https://xquik.com/api/v1/monitors", {
  method: "POST",
  headers: {
    "x-api-key": "xq_your_api_key_here",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    username: "elonmusk",
    eventTypes: ["tweet.new", "tweet.reply"],
  }),
});
const monitor = await response.json();
process.stdout.write(`${JSON.stringify(monitor, null, 2)}\n`);
```

```python
import requests

response = requests.post(
    "https://xquik.com/api/v1/monitors",
    headers={"x-api-key": "xq_your_api_key_here"},
    json={
        "username": "elonmusk",
        "eventTypes": ["tweet.new", "tweet.reply"],
    },
)
print(response.json())
```

```go
package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
)

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

    req, _ := http.NewRequest("POST", "https://xquik.com/api/v1/monitors", bytes.NewReader(body))
    req.Header.Set("x-api-key", "xq_your_api_key_here")
    req.Header.Set("Content-Type", "application/json")

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

    respBody, _ := io.ReadAll(resp.Body)
    fmt.Println(string(respBody))
}
```