Extracting Tweet Replies

Output from command in shell 25d64c:
total 128
drwxr-xr-x  11 root1  staff    352 Jun 24 01:36 .
drwxr-xr-x  12 root1  staff    384 Jun 25 06:31 ..
drwxr-xr-x   3 root1  staff     96 Jun 24 01:33 .devin
-rw-r--r--   1 root1  staff      8 Jun 24 01:15 .gitignore
drwxr-xr-x   4 root1  staff    128 Jun 24 01:15 .vercel
-rw-r--r--   1 root1  staff     22 Jun 24 01:15 .vercelignore
drwxr-xr-x  10 root1  staff    320 Jun 24 01:36 api
-rw-r--r--   1 root1  staff  45325 Jun 24 01:28 index.html
drwxr-xr-x   9 root1  staff    288 Jun 24 01:31 screenshots
-rw-r--r--   1 root1  staff   2196 Jun 24 01:01 serve.py
-rw-r--r--   1 root1  staff    166 Jun 24 01:36 vercel.json


Exit code: 0

Output from command in shell b743ae:
total 48
drwxr-xr-x   4 root1  staff   128 Jun 24 01:24 _lib
drwxr-xr-x  10 root1  staff   320 Jun 24 01:36 .
drwxr-xr-x  11 root1  staff   352 Jun 24 01:36 ..
-rw-r--r--   1 root1  staff  1120 Jun 24 01:25 add.js
-rw-r--r--   1 root1  staff  1337 Jun 24 01:25 board.js
-rw-r--r--   1 root1  staff   251 Jun 24 01:25 health.js
-rw-r--r--   1 root1  staff  2947 Jun 24 01:36 index.js
-rw-r--r--   1 root1  staff  1148 Jun 24 01:26 remove.js
-rw-r--r--   1 root1  staff  1783 Jun 24 01:36 skill.js
drwxr-xr-x   3 root1  staff    96 Jun 24 01:25 tweet
---
name: tweetington
description: Build and open a Tweetington board to view multiple tweets at once (via its API)
argument-hint: "[tweet ids or urls]"
triggers:
  - user
  - model
allowed-tools:
  - exec
  - read
permissions:
  allow:
    - Exec(curl)
---

# Tweetington

Tweetington is a multi-view for tweets (a "viewington for tweets"): it shows many
tweets at once in an auto-optimized grid. It exposes a tiny, **auth-free, stateless
HTTP API** that is ideal for agents.

- **App:** https://tweetington.aidenhuang.com/
- **API base:** https://tweetington.aidenhuang.com/api
- **Live docs:** `curl -s https://tweetington.aidenhuang.com/api`

> Set `TW_BASE` if running against a different deployment or `http://localhost:8777`
> (started via `python3 serve.py` in the app directory — the API only runs on Vercel,
> so prefer the deployed base for API calls).

## The board model (read this first)

A **board is just an ordered list of tweet ids carried in the URL**:

```
https://tweetington.aidenhuang.com/?ids=20,1985900138598895616
```

There is **no database and no auth**. To "save" or "share" a board, keep its URL.
You build/modify boards by passing ids (or full tweet URLs) to the API and getting
back a new board URL that a human can open.

## What to do when invoked

Interpret `$ARGUMENTS` as the tweets to display. They may be **bare numeric ids**,
**full tweet URLs** (`twitter.com` or `x.com`), comma/space separated — or a request
that contains such ids/urls.

1. Extract every tweet id from `$ARGUMENTS` (from `.../status/<id>` urls or bare ids).
2. Build the board and get its openable URL:
   ```bash
   BASE="${TW_BASE:-https://tweetington.aidenhuang.com}"
   curl -s "$BASE/api/add?ids=20,1985900138598895616"
   # -> { "count": 2, "ids": [...], "url": "https://.../?ids=20,1985900138598895616" }
   ```
3. (Optional) Validate / preview the tweets so you can report who/what they are:
   ```bash
   curl -s "$BASE/api/board?ids=20,1985900138598895616" \
     | python3 -c "import sys,json;[print(t.get('author',{}).get('handle'), '-', (t.get('text') or t.get('error',''))[:60]) for t in json.load(sys.stdin)['tweets']]"
   ```
   Tweets that are deleted/protected come back with an `"error"` field instead of
   author/text — mention these to the user rather than failing.
4. Give the user the **board URL** (the `url` field). Offer to open it; on macOS you
   may run `open "<url>"`.

If `$ARGUMENTS` is empty, ask the user for tweet ids/urls, or point them at the app
to load the built-in sample tweets.

## API reference

| Method | Path | Purpose |
| --- | --- | --- |
| `GET` | `/api` | Self-describing JSON docs |
| `GET` | `/api/health` | Liveness check |
| `GET` | `/api/tweet/{id}` | Resolve one tweet → `{author, text, createdAt, metrics, media, url}` |
| `GET`/`POST` | `/api/board?ids=20,123` | Resolve a whole board; returns each tweet + openable `url`. `?resolve=0` skips metadata. POST body: `{"ids":[...]}` |
| `GET`/`POST` | `/api/add?ids=123&board=20,99` | Append ids to an (optional) existing board → new board `url`. `&redirect=1` 302s straight to the live board |
| `GET`/`POST` | `/api/remove?ids=99&board=20,99,123` | Remove ids from a board → new board `url` |

Conventions:
- `ids` accepts bare numeric ids **or** full tweet URLs, comma/space separated; results are de-duped and order-preserving.
- All endpoints send `Access-Control-Allow-Origin: *` and return JSON. Errors look like `{ "error": "..." }`.
- Metadata is resolved server-side via Twitter's public syndication endpoint (no API key).

## Examples

```bash
BASE="${TW_BASE:-https://tweetington.aidenhuang.com}"

# Build a board from ids and/or urls, print the openable URL
curl -s "$BASE/api/add?ids=20,https://x.com/NASA/status/2069511462725324920" \
  | python3 -c "import sys,json;print(json.load(sys.stdin)['url'])"

# Jump straight to the rendered board (follow the redirect)
open "$BASE/api/add?ids=20&redirect=1"

# Inspect a single tweet
curl -s "$BASE/api/tweet/20"

# Append to / remove from an existing board
curl -s "$BASE/api/add?board=20,99&ids=123"
curl -s "$BASE/api/remove?board=20,99,123&ids=99"
```

## Notes & limits

- There is **no tweet search** — this skill needs the tweet ids/urls as input. If asked
  to "find tweets about X", explain that you need the specific tweets (ids or links).
- Boards are ephemeral and live entirely in the URL; opening a board link replaces the
  viewer's current local board.
- The app embeds real tweets via Twitter's official widget and enriches tile headers via
  `/api/tweet/{id}`. Embeds require an HTTPS origin (they won't render from `file://`).


Exit code: 0

Output from command in shell db5ab7:
/Users/root1/Downloads/projects/tweetington/api/_lib:
total 24
drwxr-xr-x   4 root1  staff   128 Jun 24 01:24 .
drwxr-xr-x  10 root1  staff   320 Jun 24 01:36 ..
-rw-r--r--   1 root1  staff  1228 Jun 24 01:24 http.js
-rw-r--r--   1 root1  staff  4127 Jun 24 01:28 twitter.js

/Users/root1/Downloads/projects/tweetington/api/tweet:
total 8
drwxr-xr-x   3 root1  staff   96 Jun 24 01:25 .
drwxr-xr-x  10 root1  staff  320 Jun 24 01:36 ..
-rw-r--r--   1 root1  staff  579 Jun 24 01:25 [id].js


Exit code: 0

<file-view path="/Users/root1/Downloads/projects/tweetington/api/_lib/twitter.js" start_line="1" end_line="124" total_lines="124">
  1|// Server-side tweet resolver using Twitter's public syndication endpoint.
  2|// No API key required, and unlike the browser this runs server-side so it is
  3|// not blocked by CORS. Files under api/_lib are NOT turned into routes.
  4|
  5|const SYND = 'https://cdn.syndication.twimg.com/tweet-result';
  6|
  7|// Token algorithm used by Twitter's own embed syndication (same as react-tweet).
  8|function getToken(id) {
  9|  return (
 10|    ((Number(id) / 1e15) * Math.PI).toString(6 ** 2).replace(/(0+|\.)/g, '') || 'a'
 11|  );
 12|}
 13|
 14|async function fetchRaw(id) {
 15|  const url = `${SYND}?id=${encodeURIComponent(id)}&lang=en&token=${getToken(id)}`;
 16|  let r;
 17|  try {
 18|    r = await fetch(url, {
 19|      headers: {
 20|        'User-Agent':
 21|          'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Tweetington/1.0',
 22|        Accept: 'application/json',
 23|      },
 24|    });
 25|  } catch (e) {
 26|    return { error: 'fetch failed', status: 502 };
 27|  }
 28|  if (r.status === 404) return { error: 'not found', status: 404 };
 29|  if (!r.ok) return { error: `syndication ${r.status}`, status: 502 };
 30|  const text = await r.text();
 31|  if (!text || text === 'null') return { error: 'not found', status: 404 };
 32|  let j;
 33|  try {
 34|    j = JSON.parse(text);
 35|  } catch (e) {
 36|    return { error: 'bad upstream json', status: 502 };
 37|  }
 38|  if (j.__typename && j.__typename !== 'Tweet') {
 39|    return { error: j.__typename, status: 404 }; // e.g. TweetTombstone (deleted/protected)
 40|  }
 41|  return { data: j };
 42|}
 43|
 44|function extractMedia(j) {
 45|  const out = [];
 46|  const details = j.mediaDetails || [];
 47|  for (const m of details) {
 48|    if (m.type === 'photo') {
 49|      out.push({ type: 'photo', url: m.media_url_https });
 50|    } else if (m.type === 'video' || m.type === 'animated_gif') {
 51|      const variants = (m.video_info && m.video_info.variants) || [];
 52|      const mp4 = variants
 53|        .filter((v) => v.content_type === 'video/mp4')
 54|        .sort((a, b) => (b.bitrate || 0) - (a.bitrate || 0))[0];
 55|      out.push({ type: m.type === 'animated_gif' ? 'gif' : 'video', poster: m.media_url_https, url: mp4 && mp4.url });
 56|    }
 57|  }
 58|  if (!out.length && Array.isArray(j.photos)) {
 59|    for (const p of j.photos) out.push({ type: 'photo', url: p.url });
 60|  }
 61|  return out;
 62|}
 63|
 64|// Normalize the upstream payload into Tweetington's shared tweet spec.
 65|function normalize(j) {
 66|  const u = j.user || {};
 67|  const handle = u.screen_name || '';
 68|  const id = j.id_str || String(j.id || '');
 69|  return {
 70|    id,
 71|    source: 'embed',
 72|    url: handle
 73|      ? `https://twitter.com/${handle}/status/${id}`
 74|      : `https://twitter.com/i/status/${id}`,
 75|    author: {
 76|      name: u.name || handle || 'Tweet',
 77|      handle,
 78|      verified: !!(u.verified || u.is_blue_verified),
 79|      avatar: u.profile_image_url_https || '',
 80|    },
 81|    text: j.text || '',
 82|    createdAt: j.created_at || null,
 83|    metrics: {
 84|      replies: numOrNull(j.conversation_count),
 85|      likes: numOrNull(j.favorite_count),
 86|      reposts: numOrNull(j.retweet_count),
 87|      views: numOrNull(j.view_count),
 88|    },
 89|    media: extractMedia(j),
 90|    lang: j.lang || null,
 91|  };
 92|}
 93|
 94|function numOrNull(v) {
 95|  if (v === undefined || v === null || v === '') return null;
 96|  const n = Number(v);
 97|  return Number.isFinite(n) ? n : null;
 98|}
 99|
100|async function resolveTweet(id) {
101|  const { data, error, status } = await fetchRaw(id);
102|  if (error) return { ok: false, id, error, status: status || 500 };
103|  return { ok: true, tweet: normalize(data) };
104|}
105|
106|// Accept ids/urls in many shapes: array, comma/space/newline separated string,
107|// full tweet URLs, or bare numeric ids. Returns a de-duped, ordered id list.
108|function parseIds(input) {
109|  let arr = [];
110|  if (Array.isArray(input)) arr = input;
111|  else if (input != null) arr = String(input).split(/[\s,]+/);
112|  const ids = [];
113|  for (let s of arr) {
114|    if (!s) continue;
115|    s = String(s).trim();
116|    const m = s.match(/(?:twitter\.com|x\.com)\/[^/]+\/status(?:es)?\/(\d+)/i);
117|    if (m) { ids.push(m[1]); continue; }
118|    const m2 = s.match(/\b(\d{1,25})\b/);
119|    if (m2) ids.push(m2[1]);
120|  }
121|  return [...new Set(ids)];
122|}
123|
124|module.exports = { resolveTweet, parseIds, normalize, getToken };
</file-view>

<file-view path="/Users/root1/Downloads/projects/tweetington/api/tweet/[id].js" start_line="1" end_line="13" total_lines="13">
  1|const { json, preflight } = require('../_lib/http');
  2|const { resolveTweet, parseIds } = require('../_lib/twitter');
  3|
  4|// GET /api/tweet/{id}  — resolve a single tweet to the Tweetington spec.
  5|module.exports = async (req, res) => {
  6|  if (preflight(req, res)) return;
  7|  const raw = (req.query.id || '').toString();
  8|  const [id] = parseIds(raw);
  9|  if (!id) return json(res, 400, { error: 'invalid tweet id or url', input: raw });
 10|  const r = await resolveTweet(id);
 11|  if (!r.ok) return json(res, r.status === 404 ? 404 : 502, { error: r.error, id });
 12|  json(res, 200, r.tweet);
 13|};
</file-view>

<file-view path="/Users/root1/Downloads/projects/tweetington/api/board.js" start_line="1" end_line="35" total_lines="35">
  1|const { json, preflight, baseUrl } = require('./_lib/http');
  2|const { resolveTweet, parseIds } = require('./_lib/twitter');
  3|
  4|// GET /api/board?ids=20,123        resolve a board (metadata for each tweet)
  5|// POST /api/board { "ids": [...] }  same, ids in body
  6|// add ?resolve=0 to skip metadata and just echo the normalized board.
  7|module.exports = async (req, res) => {
  8|  if (preflight(req, res)) return;
  9|
 10|  let input;
 11|  if (req.method === 'POST') {
 12|    let body = req.body;
 13|    if (typeof body === 'string') { try { body = JSON.parse(body); } catch (e) { body = body; } }
 14|    input = (body && (body.ids ?? body.id ?? body)) ?? '';
 15|  } else {
 16|    input = req.query.ids ?? req.query.id ?? req.query.board ?? '';
 17|  }
 18|
 19|  const ids = parseIds(input);
 20|  const base = baseUrl(req);
 21|  const url = ids.length ? `${base}/?ids=${ids.join(',')}` : `${base}/`;
 22|  const resolve = req.query.resolve !== '0';
 23|
 24|  let tweets;
 25|  if (resolve && ids.length) {
 26|    const results = await Promise.all(ids.map(resolveTweet));
 27|    tweets = results.map((r, i) =>
 28|      r.ok ? r.tweet : { id: ids[i], source: 'embed', url: `https://twitter.com/i/status/${ids[i]}`, error: r.error }
 29|    );
 30|  } else {
 31|    tweets = ids.map((id) => ({ id, source: 'embed', url: `https://twitter.com/i/status/${id}` }));
 32|  }
 33|
 34|  json(res, 200, { count: ids.length, ids, url, tweets });
 35|};
</file-view>

<file-view path="/Users/root1/Downloads/projects/tweetington/api/index.js" start_line="1" end_line="67" total_lines="67">
  1|const { json, preflight, baseUrl } = require('./_lib/http');
  2|
  3|// GET /api  — self-describing docs so agents can discover the API.
  4|module.exports = (req, res) => {
  5|  if (preflight(req, res)) return;
  6|  const base = baseUrl(req);
  7|  json(res, 200, {
  8|    name: 'Tweetington API',
  9|    version: '1.0.0',
 10|    description:
 11|      'Build and resolve "boards" of tweets for the Tweetington multi-view. ' +
 12|      'A board is stateless: it is just an ordered list of tweet ids carried in the URL ' +
 13|      '(?ids=20,123,456). No auth, no database. Tweet metadata is resolved server-side ' +
 14|      'via Twitter\'s public syndication endpoint (no API key).',
 15|    conventions: {
 16|      ids: 'Comma/space separated. Accepts bare numeric ids OR full tweet URLs (twitter.com or x.com).',
 17|      board: 'A board is fully described by its ids. To "save" a board, keep its url.',
 18|      cors: 'All endpoints send Access-Control-Allow-Origin: *',
 19|      responses: 'JSON. Errors look like { "error": "..." } with an appropriate status code.',
 20|    },
 21|    endpoints: [
 22|      { method: 'GET', path: '/api', desc: 'This documentation.' },
 23|      { method: 'GET', path: '/api/health', desc: 'Liveness check.' },
 24|      {
 25|        method: 'GET',
 26|        path: '/api/skill',
 27|        desc: 'The Tweetington agent skill (SKILL.md). Add ?format=json for metadata + install command.',
 28|        example: `${base}/api/skill`,
 29|      },
 30|      {
 31|        method: 'GET',
 32|        path: '/api/tweet/{id}',
 33|        desc: 'Resolve one tweet to the Tweetington spec (author, text, metrics, media).',
 34|        example: `${base}/api/tweet/20`,
 35|      },
 36|      {
 37|        method: 'GET|POST',
 38|        path: '/api/board?ids=20,123',
 39|        desc: 'Resolve a board. Returns the openable board url + each tweet resolved. POST body: {"ids":[...]}. Add resolve=0 to skip metadata.',
 40|        example: `${base}/api/board?ids=20,1985900138598895616`,
 41|      },
 42|      {
 43|        method: 'GET|POST',
 44|        path: '/api/add?ids=123&board=20,99',
 45|        desc: 'Append ids to an (optional) existing board; returns the new board url. Use redirect=1 to 302 straight to the live board.',
 46|        example: `${base}/api/add?ids=20&redirect=1`,
 47|      },
 48|      {
 49|        method: 'GET|POST',
 50|        path: '/api/remove?ids=99&board=20,99,123',
 51|        desc: 'Remove ids from a board; returns the new board url.',
 52|        example: `${base}/api/remove?board=20,99,123&ids=99`,
 53|      },
 54|    ],
 55|    quickstart: {
 56|      '1_build_a_board': `GET ${base}/api/add?ids=20,1985900138598895616`,
 57|      '2_open_it': `the "url" field, e.g. ${base}/?ids=20,1985900138598895616`,
 58|      '3_inspect_a_tweet': `GET ${base}/api/tweet/20`,
 59|    },
 60|    skill: {
 61|      description: 'An installable agent skill (SKILL.md) for using this API lives at /api/skill.',
 62|      url: `${base}/api/skill`,
 63|      install: `mkdir -p .devin/skills/tweetington && curl -s ${base}/api/skill -o .devin/skills/tweetington/SKILL.md`,
 64|    },
 65|    app: base + '/',
 66|  });
 67|};
</file-view>

Found 12 match(es) for pattern 'reply|replies|conversation' in /Users/root1/Downloads/projects/tweetington:
-- 11 matches in /Users/root1/Downloads/projects/tweetington/index.html
382|     metrics: { replies, reposts, likes, views },  // mock only
493|      ago(1), {replies:128, reposts:540, likes:4200, views:88000}, []),
496|      ago(3), {replies:902, reposts:12400, likes:91000, views:1500000}, []),
499|      ago(5), {replies:33, reposts:210, likes:1800, views:42000}, [mediaImg('px','UI preview')]),
502|      ago(8), {replies:54, reposts:430, likes:6100, views:120000}, []),
505|      ago(11), {replies:12, reposts:88, likes:990, views:23000}, []),
508|      ago(14), {replies:71, reposts:610, likes:7300, views:160000}, [mediaImg('kj','spec diagram')]),
511|      ago(20), {replies:5, reposts:22, likes:410, views:8800}, []),
514|      ago(26), {replies:140, reposts:980, likes:11200, views:300000}, []),
707|    `<span>${metricIcon('<path d="M21 11.5a8.38 8.38 0 0 1-.9 3.8 8.5 8.5 0 0 1-7.6 4.7 8.38 8.38 0 0 1-3.8-.9L3 21l1.9-5.7a8.38 8.38 0 0 1-.9-3.8 8.5 8.5 0 0 1 4.7-7.6 8.38 8.38 0 0 1 3.8-.9h.5a8.48 8.48 0 0 1 8 8z"/>')}${fmt(m.replies)}</span>
723|    window.twttr.widgets.createTweet(t.id, container, { theme: 'dark', dnt: true, conversation: 'none', align: 'center' })
-- 1 matches in /Users/root1/Downloads/projects/tweetington/api/_lib/twitter.js
84|      replies: numOrNull(j.conversation_count),

Output from command in shell 3de6ea:
{}

Exit code: 0

Output from command in shell 53abd7:
{
    "__typename": "Tweet",
    "favorite_count": 308149,
    "lang": "en",
    "created_at": "2006-03-21T20:50:14.000Z",
    "display_text_range": [
        0,
        24
    ],
    "entities": {},
    "id_str": "20",
    "text": "just setting up my twttr",
    "user": {
        "id_str": "12",
        "name": "jack",
        "screen_name": "jack",
        "is_blue_verified": true,
        "profile_image_shape": "Circle",
        "verified": false,
        "profile_image_url_https": "https://pbs.twimg.com/profile_images/1661201415899951105/azNjKOSH_normal.jpg",
        "highlighted_label": {
            "badge": {
                "url": "https://pbs.twimg.com/profile_images/1285655593592791040/HtwPZgej_bigger.jpg"
            },
            "description": "Square",
            "url": {
                "url": "https://twitter.com/Square",
                "url_type": "DeepLink"
            },
            "user_label_display_type": "Badge",
            "user_label_type": "BusinessLabel"
        }
    },
    "edit_control": {
        "edit_tweet_ids": [
            "20"
        ],
        "editable_until_msecs": "1142976014000",
        "edits_remaining": "5",
        "is_edit_eligible": true
    },
    "conversation_count": 17945,
    "news_action_type": "conversation",
    "isEdited": false,
    "isStaleEdit": false
}


Exit code: 0

# Web Search Results for "twitter syndication cdn.syndication.twimg.com conversation replies endpoint"

## 1. Syndication API | emusks - Reverse-engineered Twitter clients for JavaScript
URL: https://emusks.tiago.zip/more/syndication

Syndication API | emusks
...
# Syndication API ​
...
Syndication is the internal Twitter API used for generating tweet embeds, unauthenticated. It's great for converting thousands of tweet IDs to actual tweets, fast, and needing an account that could get suspended.
...
As far as I know, this API has no ratelimits. This API only supports fetching tweets as profile timelines have been effectively removed from the embeds API and no longer work.
...
## syndication.getTweet(tweetId) ​

js
...
```
import Emusks from "emusks";
...
const client = new Emusks();
...
// you don't have to authenticate!

const tweet = await client.syndication.getTweet("2023357708301455483");
```
...
"en",
...
,
...
000Z",
  "display_text_range": [ 0, 155 ],
  "entities": {
    "hashtags": {},
    "urls": {},
    "user_mentions": {},
    "symbols": {}
  },
  "id_str": "2023357708301455483",
  "text": "Underdocumented: `bun build --compile` supports `--splitting -format=esm` Lazy load code embedded in your single-file executable to improve CLI start time",
  "user": {
    "id_str": "2489440172",
    "name": "Jarred Sumner",
    "screen_name": "jarredsumner",
    "is_blue_verified": true,
    "profile_image_shape": "Circle",
    "verified": false,
    "profile_image_url_https": "https://pbs.twimg.com/profile_images/1342417825483300864/Vz4ChOFG_normal.jpg",
    "highlighted_label": {
      "description": "Bun",
      "badge": {
        "url": "https://pbs.twimg.com/profile_images/1809959835884216320/MDn6rbnJ_bigger.jpg"
      },
      "url": {
        "url": "https://twitter.com/bunjavascript",
        "url_type": "DeepLink"
      },
      "user_label_type": "BusinessLabel",
      "user_label_display_type": "Badge"
    }
  },
  "edit_control": {
    "edit_tweet_ids": [ "2023357708301455483" ],
    "editable_until_msecs": "1771244644000",
    "is_edit_eligible": true,
    "edits_remaining": "5"
  },
  "conversation_count": 1,
  "news_action_type": "conversation",
  "isEdited": false,
  "isStaleEdit":...

## 2. packages/react-tweet/src/api/get-tweet.ts at 03f4db52f393ddf84e62a42222d49c765bbd3420 · vercel/react-tweet
URL: https://github.com/vercel/react-tweet/blob/03f4db52f393ddf84e62a42222d49c765bbd3420/packages/react-tweet/src/api/get-tweet.ts

# File: vercel/react-tweet/packages/react-tweet/src/api/get-tweet.ts

- Repository: vercel/react-tweet | Embed tweets in your React application. | 2K stars | TypeScript
- Branch: 03f4db52f393ddf84e62a42222d49c765bbd3420

```ts
import type { Tweet } from './types/index.js'

const SYNDICATION_URL = 'https://cdn.syndication.twimg.com'

export class TwitterApiError extends Error {
  status: number
  data: any

  constructor({
    message,
    status,
    data,
  }: {
    message: string
    status: number
    data: any
  }) {
    super(message)
    this.name = 'TwitterApiError'
    this.status = status
    this.data = data
  }
}

const TWEET_ID = /^[0-9]+$/

/**
 * Fetches a tweet from the Twitter syndication API.
 */
export async function getTweet(
  id: string,
  fetchOptions?: RequestInit
): Promise<Tweet | undefined> {
  if (id.length > 40 || !TWEET_ID.test(id)) {
    throw new Error(`Invalid tweet id: ${id}`)
  }

  const url = new URL(`${SYNDICATION_URL}/tweet-result`)

  url.searchParams.set('id', id)
  url.searchParams.set('lang', 'en')
  url.searchParams.set(
    'features',
    [
      'tfw_timeline_list:',
      'tfw_follower_count_sunset:true',
      'tfw_tweet_edit_backend:on',
      'tfw_refsrc_session:on',
      'tfw_show_business_verified_badge:on',
      'tfw_duplicate_scribes_to_settings:on',
      'tfw_show_blue_verified_badge:on',
      'tfw_legacy_timeline_sunset:true',
      'tfw_show_gov_verified_badge:on',
      'tfw_show_business_affiliate_badge:on',
      'tfw_tweet_edit_frontend:on',
    ].join(';')
  )

  const res = await fetch(url.toString(), fetchOptions)
  const isJson = res.headers.get('content-type')?.includes('application/json')
  const data = isJson ? await res.json() : undefined

  if (res.ok) return data
  if (res.status === 404) return

  throw new TwitterApiError({
    message: typeof data.error === 'string' ? data.error : 'Bad request.',
    status: res.status,
    data,
  })
}

```

## 3. How to prerender Tweets without using the official Twitter APIs | Stefan Judis Web Development
URL: https://www.stefanjudis.com/blog/how-to-prerender-tweets-without-using-the-official-twitter-apis/

Disclaimer: I gave up on using the undocumented Twitter API endpoint because it's unpredictable. Twitter wants to save free API calls and ideally get rid of free and API-based data scraping. The API endpoint described below (`cdn.syndication.twimg.com`) fails randomly and returns empty response bodies. It's a terrible developer experience because all calls return a`200` status code.
...
Under the hood, react-tweet reverse-engineers the Twitter's Embed API to fetch data for a given tweet and renders it in the same style as Twitter's embedded iframe.
...
The key is that Twitter's original`widget.js` talks to an open API at`cdn.syndication.twimg.com`. This API includes most of the needed data to render a Tweet on your sites (unfortunately, retweet count is unavailable). Reverse engineering the response takes some time but is worth it because, as Vercel says, "`react-tweet` uses 35x less client-side JavaScript than the Twitter's Native embed".
...
Update: In August 2023 it looks like Twitter "secured" the API with a required token. Luckily, our friends at Vercel reverce engineered the API yet again.

## 4. How do you learn about the twitter "API"? · Issue #76 · vercel/react-tweet
URL: https://github.com/vercel/react-tweet/issues/76

> > these apis can break at anytime
> 
> You can discover the unofficial apis by looking at blogs/repos from people that have done it before eg: the [fa0311/TwitterInternalAPIDocument](https://github.com/fa0311/TwitterInternalAPIDocument) repo or checking the devtools network tab, specifically the `Fetch/XHR` tab.
> 
> some examples
> 
> ## `cdn.syndication.twimg.com/tweet-result?`
> 
> Used at [publish.twitter.com](https://publish.twitter.com) for the official embed but not documented.
> 
> Usage:
> 
> Make `GET` request to [`cdn.syndication.twimg.com/tweet-result?id=20&lang=en`](https://cdn.syndication.twimg.com/tweet-result?id=20)
> 
> - No special headers requred, just a valid tweet id. (You can visit the url from a browser)
> - Doesn't include all the tweet data eg: spaces, longform tweets, rt count
> 
> Example using javascript
> 
> ```js
> async function getTweet(id) {
> const url = `https://cdn.syndication.twimg.com/tweet-result?id=${id}`
> const response = await fetch(url)
> const json = await response.json()
> return json
> }
> ```
...
> 
> ## `api.twitter.com/*`
> 
> Used by the official twitter web client so it's very rich. It's always changing and fields can be deleted without warning.
> eg: the co-tweet feature was removed from all api responses.
> 
> Usage:
> 
> Get a (public) bearer token from devtools in an incognito [twitter.com](https://twitter.com/) tab. The current one is
> `AAAAAAAAAAAAAAAAAAAAANRILgAAAAAAnNwIzUejRCOuH5E6I8xnZz4puTs=1Zv7ttfk8LF81IUq16cHjhLTvJu4FA33AGWWjCpTnA`
> but it might be changed.
...
>
...
api.twitter
...
> 
>
...
found a useful repo automatically documenting all
...
endpoints at https://
...
.com/fa0311/TwitterInternalAPIDocument
...
> 
>
...
can also use the genereated headers in some offical & documented REST endpoints that don'
...
requre authentication eg: `https://api.
...
.com/
...
/lookup.
...
.com/
...
/docs/twitter-api/v
...
/post-and
...
/api-
...
by making a
...
the /1
...
include the authorization header
...
...

## 5. nuclide-research/API-God
URL: https://github.com/nuclide-research/API-God

A second path needs no login at all. The syndication CDN (`cdn.syndication.twimg.com/tweet-result?id=`) returns a full tweet by id, keyless, with no per-IP limit observed at 250 requests. API-God uses it to hydrate tweet ids without touching any account rate-limit budget.
...
- Keyless reads via authenticated Playwright session: `SearchTimeline`, `UserTweets`, `UserTweetsAndReplies`, `ListLatestTweetsTimeline`, `TweetResultsByRestIds`
- Syndication CDN path: full tweet by id, no login required, no per-IP limit observed
- Rate-limit census of 93 read operations: full per-op bucket map committed as JSON
- Continuous ingest (`ingest.py`): poll-on-interval, dedup across polls, append only new tweets
- Field-exposure diff (`fielddiff.py`): keyless CDN vs authed `TweetResultsByRestIds`, 86 authed-only fields
- xAI backend option (`--backend xai`): paid path, no account risk
- 51 offline pytest tests, no network, no browser, no RPC
...
| Mode | Command | Reads |
|------|---------|-------|
| Search | `python xsearch.py "solana depin"` | `SearchTimeline` |
| Track one account | `python xsearch.py elonmusk --track` | `UserTweets` |
| Track with replies | `python xsearch.py elonmusk --track --replies` | `UserTweetsAndReplies` |
| Track a List | `python xsearch.py --list ` | `ListLatestTweetsTimeline` |
| Hydrate ids (keyless) | `cat ids.txt \| python xsearch.py --hydrate` | syndication CDN |
| Batch hydrate (authed) | `cat ids.txt \| python xsearch.py --batch` | `TweetResultsByRestIds` |
| Probe rate limits | `python xsearch.py "query" --probe` | search or track endpoint |
| xAI backend | `python xsearch.py "query" --backend xai` | xAI x_search + CDN |
| Combined | `python xsearch.py "query" --backend both` | session + xAI, merged |
...
| Endpoint | Limit |
|----------|-------|
| `SearchTimeline` | 50 requests / 15 min rolling, then HTTP 429 |
| `UserTweets` | separate bucket; serves 200 while search is 429'd |
| `ListLatestTweetsTimeline` | 500 / 15 min; one call returns ever...

Output from command in shell a8c468:
guest_token=2070414103772889208
---



Exit code: 0

Output from command in shell 0efd3b:
guest_token=2070414171032760675
{"errors":[{"message":"Sorry, that page does not exist","code":34}]}


Exit code: 0