> ## 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.

# List radar items

> Fetch free Radar trends with filters and cursor pagination

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

Get trending topics and news from Xquik's own infrastructure. Filter by source identifier, category, region, and time window.

Radar is authenticated but free. It does not require an active subscription and does not consume credits.

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

## Query parameters

<ParamField query="source" type="string">
  Filter by Radar source identifier. Omit to return all available streams. Use the `source` value returned on radar items when you need to poll one stream.
</ParamField>

<ParamField query="category" type="string">
  Filter by category. One of: `general`, `tech`, `dev`, `science`, `culture`, `politics`, `business`, `entertainment`. Omit to return all categories. Categories are assigned automatically based on source and content.
</ParamField>

<ParamField query="hours" type="integer" default="6">
  Look-back window in hours. Range: 1-72. Smaller values surface the most recent trends; larger values give a broader snapshot. Default is 6 hours.
</ParamField>

<ParamField query="limit" type="integer" default="50">
  Items per page. Range: 1-100. Use smaller values (10-20) for quick polling, larger values for batch processing. Default is 50.
</ParamField>

<ParamField query="region" type="string" default="global">
  Region filter. Values: `US`, `GB`, `TR`, `ES`, `DE`, `FR`, `JP`, `IN`, `BR`, `CA`, `MX`, `global`. Default `global` returns items from all regions.
</ParamField>

<ParamField query="after" type="string">
  Cursor for pagination. Use the `nextCursor` value from the previous response. Cursors are opaque base64 strings and should not be constructed manually.
</ParamField>

## Response

<ResponseField name="items" type="RadarItem[]" required>
  Array of radar items sorted by score (descending).
</ResponseField>

<ResponseField name="hasMore" type="boolean" required>
  Whether more items are available after this page.
</ResponseField>

<ResponseField name="nextCursor" type="string">
  Pagination cursor. Present only when `hasMore` is `true`. Pass as the `after` query parameter on the next request.
</ResponseField>

### RadarItem fields

<ResponseField name="id" type="string" required>
  Radar item identifier.
</ResponseField>

<ResponseField name="title" type="string" required>
  Item title.
</ResponseField>

<ResponseField name="description" type="string">
  Item description. Omitted when unavailable.
</ResponseField>

<ResponseField name="url" type="string">
  Link to the original source. Omitted when unavailable.
</ResponseField>

<ResponseField name="imageUrl" type="string">
  Image URL. Omitted when unavailable.
</ResponseField>

<ResponseField name="source" type="string" required>
  Radar source identifier. Pass this value as the `source` query parameter to filter future pages to the same stream.
</ResponseField>

<ResponseField name="sourceId" type="string" required>
  Unique identifier within the source.
</ResponseField>

<ResponseField name="category" type="string" required>
  One of: `general`, `tech`, `dev`, `science`, `culture`, `politics`, `business`, `entertainment`.
</ResponseField>

<ResponseField name="region" type="string" required>
  Region code (e.g. `US`, `TR`, `global`).
</ResponseField>

<ResponseField name="language" type="string" required>
  BCP-47 language code (e.g. `en`, `tr`, `ja`).
</ResponseField>

<ResponseField name="score" type="integer" required>
  Relevance score (0-10,000). Higher is more trending.
</ResponseField>

<ResponseField name="metadata" type="object" required>
  Stream-specific data. Fields vary by item.
</ResponseField>

<ResponseField name="publishedAt" type="string" required>
  ISO 8601 timestamp of when the item was published or detected.
</ResponseField>

<ResponseField name="createdAt" type="string" required>
  ISO 8601 timestamp of when the item was indexed.
</ResponseField>

## Metadata

The `metadata` object contains stream-specific fields. Common fields include:

| Field            | Description                                      |
| ---------------- | ------------------------------------------------ |
| `author`         | Source author or publisher handle when available |
| `category`       | Additional stream category when available        |
| `language`       | Language or programming language when available  |
| `numberComments` | Comment count when available                     |
| `points`         | Stream score or point count when available       |
| `starsToday`     | Daily star count when available                  |
| `subreddit`      | Community identifier when available              |
| `views`          | View count when available                        |
| `volume24hr`     | 24-hour volume when available                    |

## Examples

<CodeGroup>
  ```bash cURL theme={null}
  curl "https://xquik.com/api/v1/radar?category=tech&hours=12&limit=10" \
    -H "x-api-key: xq_YOUR_KEY_HERE" | jq
  ```

  ```javascript Node.js theme={null}
  const response = await fetch(
    "https://xquik.com/api/v1/radar?category=tech&hours=12&limit=10",
    { headers: { "x-api-key": "xq_YOUR_KEY_HERE" } },
  );
  const { items, hasMore, nextCursor } = await response.json();

  for (const item of items) {
    console.log(`[${item.source}] ${item.title} (score: ${item.score})`);
  }
  ```

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

  response = requests.get(
      "https://xquik.com/api/v1/radar",
      headers={"x-api-key": "xq_YOUR_KEY_HERE"},
      params={"category": "tech", "hours": 12, "limit": 10},
  )
  data = response.json()

  for item in data["items"]:
      print(f"[{item['source']}] {item['title']} (score: {item['score']})")
  ```

  ```go Go theme={null}
  req, _ := http.NewRequest("GET", "https://xquik.com/api/v1/radar?category=tech&hours=12&limit=10", nil)
  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 struct {
      Items      []map[string]interface{} `json:"items"`
      HasMore    bool                     `json:"hasMore"`
      NextCursor string                   `json:"nextCursor"`
  }
  json.NewDecoder(resp.Body).Decode(&data)

  for _, item := range data.Items {
      fmt.Printf("[%s] %s (score: %.0f)\n", item["source"], item["title"], item["score"])
  }
  ```
</CodeGroup>

**Response:**

<Tabs>
  <Tab title="200 OK">
    ```json theme={null}
    {
      "items": [
        {
          "id": "12345",
          "title": "Open-source deployment platform launches preview environments",
          "description": "A self-hosted platform adds preview environments and edge functions.",
          "url": "https://example.com/radar/items/12345",
          "source": "dev",
          "sourceId": "dev_12345",
          "category": "tech",
          "region": "global",
          "language": "en",
          "score": 450,
          "metadata": {
            "starsToday": 450,
            "language": "TypeScript"
          },
          "publishedAt": "2026-03-04T08:30:00.000Z",
          "createdAt": "2026-03-04T08:35:00.000Z"
        }
      ],
      "hasMore": true,
      "nextCursor": "NDUwfDIwMjYtMDMtMDRUMDg6MzA6MDAuMDAwWnwxMjM0NQ=="
    }
    ```
  </Tab>

  <Tab title="400 Invalid Input">
    ```json theme={null}
    { "error": "invalid_input" }
    ```

    Invalid `source` or `category` value. Numeric `hours` and `limit` values are clamped to the accepted range; non-numeric values fall back to defaults.
  </Tab>

  <Tab title="401 Unauthenticated">
    ```json theme={null}
    { "error": "unauthenticated" }
    ```

    Missing or invalid API key. Check the `x-api-key` header value.
  </Tab>

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

    Wait for the `Retry-After` value before requesting another Radar page.
  </Tab>
</Tabs>

## Pagination

Radar uses cursor-based pagination. When `hasMore` is `true`, pass the `nextCursor` value as the `after` query parameter to fetch the next page.

<CodeGroup>
  ```bash cURL theme={null}
  # First page
  curl "https://xquik.com/api/v1/radar?limit=20" \
    -H "x-api-key: xq_YOUR_KEY_HERE" | jq

  # Next page
  curl "https://xquik.com/api/v1/radar?limit=20&after=NDUwfDIwMjYtMDMtMDRUMDg6MzA6MDAuMDAwWnwxMjM0NQ==" \
    -H "x-api-key: xq_YOUR_KEY_HERE" | jq
  ```

  ```javascript Node.js theme={null}
  let cursor = undefined;
  const allItems = [];

  do {
    const params = new URLSearchParams({ limit: "20" });
    if (cursor) params.set("after", cursor);

    const data = await fetch(
      `https://xquik.com/api/v1/radar?${params}`,
      { headers: { "x-api-key": "xq_YOUR_KEY_HERE" } },
    ).then((r) => r.json());

    allItems.push(...data.items);
    cursor = data.hasMore ? data.nextCursor : undefined;
  } while (cursor);
  ```

  ```python Python theme={null}
  all_items = []
  cursor = None

  while True:
      params = {"limit": 20}
      if cursor:
          params["after"] = cursor

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

      all_items.extend(data["items"])

      if data["hasMore"]:
          cursor = data["nextCursor"]
      else:
          break
  ```

  ```go Go theme={null}
  var allItems []map[string]interface{}
  cursor := ""

  for {
      url := "https://xquik.com/api/v1/radar?limit=20"
      if cursor != "" {
          url += "&after=" + cursor
      }

      req, _ := http.NewRequest("GET", url, nil)
      req.Header.Set("x-api-key", "xq_YOUR_KEY_HERE")

      resp, _ := http.DefaultClient.Do(req)
      var data struct {
          Items      []map[string]interface{} `json:"items"`
          HasMore    bool                     `json:"hasMore"`
          NextCursor string                   `json:"nextCursor"`
      }
      json.NewDecoder(resp.Body).Decode(&data)
      resp.Body.Close()

      allItems = append(allItems, data.Items...)

      if !data.HasMore {
          break
      }
      cursor = data.NextCursor
  }
  ```
</CodeGroup>

<Note>
  **Next steps:** [Trends guide](/guides/trends) for content strategy workflows · [Create Tweet](/api-reference/x-write/create-tweet) to post about trending topics · [Compose](/api-reference/compose/create) to generate AI-drafted tweets from radar items
</Note>