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

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

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

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

}
{
  "items": [
    {}
  ],
  "hasMore": true,
  "nextCursor": "<string>",
  "id": "<string>",
  "title": "<string>",
  "description": "<string>",
  "url": "<string>",
  "imageUrl": "<string>",
  "source": "<string>",
  "sourceId": "<string>",
  "category": "<string>",
  "region": "<string>",
  "language": "<string>",
  "score": 123,
  "metadata": {},
  "publishedAt": "<string>",
  "createdAt": "<string>"
}
Free - does not consume credits
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

x-api-key
string
required
Your API key. Session cookie authentication is also supported. Generate a key from the dashboard.

Query parameters

source
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.
category
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.
hours
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.
limit
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.
region
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.
after
string
Cursor for pagination. Use the nextCursor value from the previous response. Cursors are opaque base64 strings and should not be constructed manually.

Response

items
RadarItem[]
required
Array of radar items sorted by score (descending).
hasMore
boolean
required
Whether more items are available after this page.
nextCursor
string
Pagination cursor. Present only when hasMore is true. Pass as the after query parameter on the next request.

RadarItem fields

id
string
required
Radar item identifier.
title
string
required
Item title.
description
string
Item description. Omitted when unavailable.
url
string
Link to the original source. Omitted when unavailable.
imageUrl
string
Image URL. Omitted when unavailable.
source
string
required
Radar source identifier. Pass this value as the source query parameter to filter future pages to the same stream.
sourceId
string
required
Unique identifier within the source.
category
string
required
One of: general, tech, dev, science, culture, politics, business, entertainment.
region
string
required
Region code (e.g. US, TR, global).
language
string
required
BCP-47 language code (e.g. en, tr, ja).
score
integer
required
Relevance score (0-10,000). Higher is more trending.
metadata
object
required
Stream-specific data. Fields vary by item.
publishedAt
string
required
ISO 8601 timestamp of when the item was published or detected.
createdAt
string
required
ISO 8601 timestamp of when the item was indexed.

Metadata

The metadata object contains stream-specific fields. Common fields include:
FieldDescription
authorSource author or publisher handle when available
categoryAdditional stream category when available
languageLanguage or programming language when available
numberCommentsComment count when available
pointsStream score or point count when available
starsTodayDaily star count when available
subredditCommunity identifier when available
viewsView count when available
volume24hr24-hour volume when available

Examples

curl "https://xquik.com/api/v1/radar?category=tech&hours=12&limit=10" \
  -H "x-api-key: xq_YOUR_KEY_HERE" | jq
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})`);
}
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']})")
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"])
}
Response:
{
  "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=="
}

Pagination

Radar uses cursor-based pagination. When hasMore is true, pass the nextCursor value as the after query parameter to fetch the next page.
# 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
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);
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
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
}
Next steps: Trends guide for content strategy workflows · Create Tweet to post about trending topics · Compose to generate AI-drafted tweets from radar items
Last modified on June 15, 2026