Twitter media downloader API for photos & video

curl -X POST https://xquik.com/api/v1/x/media/download \
  -H "x-api-key: xq_YOUR_KEY_HERE" \
  -H "Content-Type: application/json" \
  -d '{
    "tweetInput": "1893456789012345678"
  }' | jq

curl -X POST https://xquik.com/api/v1/x/media/download \
  -H "x-api-key: xq_YOUR_KEY_HERE" \
  -H "Content-Type: application/json" \
  -d '{
    "tweetIds": ["1893456789012345678", "1893456789012345999", "1893456789012346000"]
  }' | jq

const singleTweetId = "1893456789012345678";

// Single tweet
const single = await fetch("https://xquik.com/api/v1/x/media/download", {
  method: "POST",
  headers: {
    "x-api-key": "xq_YOUR_KEY_HERE",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({ tweetInput: singleTweetId }),
});
const singleResult = await single.json();
const singleRow = {
  input_mode: "single",
  requested_tweet_id: singleTweetId,
  tweet_id: singleResult.tweetId,
  gallery_url: singleResult.galleryUrl,
  cache_hit: singleResult.cacheHit,
};
process.stdout.write(`${JSON.stringify(singleRow)}\n`);

const bulkTweetIds = ["1893456789012345678", "1893456789012345999"];

// Bulk (up to 50 tweets)
const bulk = await fetch("https://xquik.com/api/v1/x/media/download", {
  method: "POST",
  headers: {
    "x-api-key": "xq_YOUR_KEY_HERE",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({ tweetIds: bulkTweetIds }),
});
const bulkResult = await bulk.json();
const bulkRow = {
  input_mode: "bulk",
  requested_tweet_ids: bulkTweetIds,
  gallery_url: bulkResult.galleryUrl,
  successful_tweet_count: bulkResult.totalTweets,
  media_item_count: bulkResult.totalMedia,
};
process.stdout.write(`${JSON.stringify(bulkRow)}\n`);

import json
import requests

single_tweet_id = "1893456789012345678"

# Single tweet
single = requests.post(
    "https://xquik.com/api/v1/x/media/download",
    headers={"x-api-key": "xq_YOUR_KEY_HERE"},
    json={"tweetInput": single_tweet_id},
)
single_result = single.json()
single_row = {
    "input_mode": "single",
    "requested_tweet_id": single_tweet_id,
    "tweet_id": single_result["tweetId"],
    "gallery_url": single_result["galleryUrl"],
    "cache_hit": single_result["cacheHit"],
}
print(json.dumps(single_row))

bulk_tweet_ids = ["1893456789012345678", "1893456789012345999"]

# Bulk (up to 50 tweets)
bulk = requests.post(
    "https://xquik.com/api/v1/x/media/download",
    headers={"x-api-key": "xq_YOUR_KEY_HERE"},
    json={"tweetIds": bulk_tweet_ids},
)
bulk_result = bulk.json()
bulk_row = {
    "input_mode": "bulk",
    "requested_tweet_ids": bulk_tweet_ids,
    "gallery_url": bulk_result["galleryUrl"],
    "successful_tweet_count": bulk_result["totalTweets"],
    "media_item_count": bulk_result["totalMedia"],
}
print(json.dumps(bulk_row))

package main

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

type MediaDownloadResponse struct {
    CacheHit    bool   `json:"cacheHit"`
    GalleryURL  string `json:"galleryUrl"`
    TweetID     string `json:"tweetId"`
    TotalMedia  int    `json:"totalMedia"`
    TotalTweets int    `json:"totalTweets"`
}

type MediaDownloadRow struct {
    InputMode        string `json:"input_mode"`
    RequestedTweetID string `json:"requested_tweet_id"`
    TweetID          string `json:"tweet_id"`
    GalleryURL       string `json:"gallery_url"`
    CacheHit         bool   `json:"cache_hit"`
}

func main() {
    // Single tweet
    tweetID := "1893456789012345678"
    payload, _ := json.Marshal(map[string]interface{}{
        "tweetInput": tweetID,
    })

    req, err := http.NewRequest("POST", "https://xquik.com/api/v1/x/media/download", bytes.NewReader(payload))
    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 result MediaDownloadResponse
    if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
        log.Fatal(err)
    }

    row := MediaDownloadRow{
        InputMode:        "single",
        RequestedTweetID: tweetID,
        TweetID:          result.TweetID,
        GalleryURL:       result.GalleryURL,
        CacheHit:         result.CacheHit,
    }
    output, err := json.Marshal(row)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println(string(output))
}