How to Export Twitter/X Bookmarks

Org Status: 🟡 Dormant Cloudflare: N/A Last Audited: 2026-04-28

Twitter/X has no native bookmark export. You can save thousands of tweets, but there is no button to download them. This article covers every viable extraction method — from GraphQL interception to the official API — with full working code for each. By the end you will know exactly which approach fits your use case and have copy-paste code to make it work.

What you will learn:

• Why Twitter deliberately prevents bookmark export and what technical constraints exist
• How to intercept Twitter’s internal GraphQL responses to capture full tweet data passively
• How to scrape bookmarks from the DOM with auto-scroll for a quick-and-dirty export
• How to use the official Bookmarks API (and why it costs $200/month for 800 tweets)
• How to build a local-first bookmark database with IndexedDB and folder management
• How to combine GraphQL interception with auto-scroll for the best hybrid approach
• How Twitter detects automation and why browser extensions bypass those defenses
• How to structure exported data for AI/LLM ingestion, CSV analysis, or archival

1. The Problem
2. Core Concepts
3. Method 1: GraphQL/XHR Interception
4. Method 2: DOM Scraping with Auto-Scroll
5. Method 3: Official Twitter API
6. Method 4: Hybrid Local Database
7. Method 5: Console Scripts and Userscripts
8. The Best Hybrid Approach
9. Handling Anti-Automation
10. Data Formats and Export Targets
11. Comparison Matrix
12. Decision Tree
13. Anti-Patterns
14. References

Twitter launched bookmarks in February 2018. Six years later, there is still no export button. This is not an oversight. It is a deliberate product decision to keep your data locked inside the platform.

Why Twitter does not let you export bookmarks

1. Engagement retention — Bookmarks give you a reason to come back. An exported list does not.
2. No regulatory pressure — GDPR data exports include tweets you wrote, not tweets you bookmarked. Bookmarks reference other people’s content, so Twitter argues they are not “your data” in the regulatory sense.
3. API tier gating — The Bookmarks API endpoint exists but requires the Basic tier ($200/month). This prices out casual users and individual developers.
4. 800-tweet hard cap — Even with the paid API, you only get your 800 most recent bookmarks. If you have 3,000 bookmarks, the oldest 2,200 are inaccessible through any official channel.

What this means in practice

• You cannot search your bookmarks (Twitter added search in 2023, but it is unreliable for large collections)
• You cannot back up bookmarks before they vanish (deleted tweets disappear from bookmarks silently)
• You cannot use bookmarks in external tools — note-taking apps, AI assistants, research databases
• You cannot migrate bookmarks if you switch accounts

What changes if you solve this

A working bookmark export pipeline turns Twitter from a black hole of saved links into a structured knowledge base. You can feed bookmarks into an LLM for summarization, build a personal search engine over saved tweets, or simply have a backup before Twitter changes its mind about something.

Key insight: The gap between “Twitter will not let you export bookmarks” and “it is technically impossible” is enormous. Twitter’s web app fetches your bookmarks through a GraphQL API that returns rich JSON. Your browser already has this data. The question is how to capture it.

Before diving into methods, you need to understand the architecture Twitter’s web app uses to render bookmarks. Every method exploits a different layer of this stack.

Twitter’s Internal GraphQL API

Twitter’s web app is a React single-page application. When you visit x.com/i/bookmarks, the app makes a GraphQL request to an internal endpoint:

GET /i/api/graphql/{queryId}/Bookmarks?variables={...}&features={...}

The queryId is a hash that changes with deployments but the operation name Bookmarks is stable. The response contains the full tweet object — text, author, metrics, media URLs, timestamps — everything.

// The shape of Twitter's internal GraphQL bookmark response
interface BookmarkTimelineResponse {
  data: {
    bookmark_timeline_v2: {
      timeline: {
        instructions: TimelineInstruction[];
      };
    };
  };
}

interface TimelineInstruction {
  type: 'TimelineAddEntries' | 'TimelineTerminateTimeline' | 'TimelineClearCache';
  entries?: TimelineEntry[];
}

interface TimelineEntry {
  entryId: string;        // "tweet-1234567890"
  sortIndex: string;      // pagination cursor
  content: {
    entryType: 'TimelineTimelineItem' | 'TimelineTimelineCursor';
    itemContent?: {
      __typename: 'TimelineTweet';
      tweet_results: {
        result: TweetResult;
      };
    };
    // Cursor entries have value + cursorType instead
    value?: string;
    cursorType?: 'Top' | 'Bottom';
  };
}

interface TweetResult {
  __typename: 'Tweet';
  rest_id: string;
  core: {
    user_results: {
      result: {
        core: {
          screen_name: string;
          name: string;
        };
        legacy: {
          screen_name: string;
          followers_count: number;
          verified: boolean;
        };
        is_blue_verified: boolean;
      };
    };
  };
  legacy: {
    full_text: string;
    created_at: string;        // "Mon Jan 01 00:00:00 +0000 2024"
    favorite_count: number;
    retweet_count: number;
    reply_count: number;
    quote_count: number;
    bookmark_count: number;
    entities: {
      urls: Array<{ expanded_url: string; display_url: string }>;
      media?: Array<{ media_url_https: string; type: string }>;
    };
    in_reply_to_status_id_str?: string;
  };
  views?: {
    count: string;
  };
}

Key insight: Twitter’s internal API returns far richer data than the official v2 API. You get view counts, bookmark counts, full entity metadata, and quoted tweet chains. The official API gives you a flat subset.

The Two Execution Contexts

Chrome extensions run code in two isolated worlds:

// ISOLATED world (default) — has extension APIs, cannot see page JS
// content.js runs here — can access chrome.runtime, chrome.storage
// CANNOT access window.fetch, XMLHttpRequest as the page sees them

// MAIN world — shares JS context with the page
// interceptor.js runs here — can monkey-patch fetch/XHR
// CANNOT access chrome.runtime or any extension APIs

This distinction is critical. To intercept Twitter’s network requests, your code MUST run in the MAIN world. The ISOLATED world sees a clean XMLHttpRequest and fetch — not the ones Twitter’s app is using.

In Manifest V3, you declare the world in your manifest:

{
  "content_scripts": [
    {
      "matches": ["*://x.com/*", "*://twitter.com/*"],
      "js": ["interceptor.js"],
      "world": "MAIN",
      "run_at": "document_start"
    },
    {
      "matches": ["*://x.com/*", "*://twitter.com/*"],
      "js": ["content.js"],
      "run_at": "document_idle"
    }
  ]
}

The MAIN world script communicates with the ISOLATED content script through CustomEvent on window:

// In MAIN world (interceptor.js) — dispatches captured data
window.dispatchEvent(
  new CustomEvent('bookmark:data', {
    detail: { tweets: parsedTweets }
  })
);

// In ISOLATED world (content.js) — receives and forwards to background
window.addEventListener('bookmark:data', (event: CustomEvent) => {
  chrome.runtime.sendMessage({
    type: 'BOOKMARKS_CAPTURED',
    tweets: event.detail.tweets
  });
});

Pagination via Cursor

Twitter uses cursor-based pagination. Each response includes cursor entries at the top and bottom of the entries array:

// Extract the bottom cursor for next page
function extractBottomCursor(entries: TimelineEntry[]): string | null {
  for (const entry of entries) {
    if (
      entry.content.entryType === 'TimelineTimelineCursor' &&
      entry.content.cursorType === 'Bottom'
    ) {
      return entry.content.value ?? null;
    }
  }
  return null;
}

The web app triggers pagination by scrolling. When you reach the bottom, it fires another GraphQL request with the cursor value. This is why auto-scroll is part of every serious export approach.

The best approach. Intercept Twitter’s own network requests, capture the full GraphQL response, and parse it. Zero additional API calls. Full tweet data. Works as long as the web app works.

How it works

1. A script running in the page context monkey-patches window.fetch and/or XMLHttpRequest.prototype.open
2. Every time Twitter makes a GraphQL request, the patched function checks if the operation name matches Bookmarks
3. When it matches, the response body is cloned and parsed
4. The parsed tweet data is emitted via CustomEvent to the extension’s content script (or stored directly if running as a userscript)

Full implementation: fetch interceptor

Twitter’s web app primarily uses fetch, not XMLHttpRequest. Modern interceptors should patch both, but fetch is the primary target.

// interceptor.ts — MAIN world, document_start
// Monkey-patches window.fetch to passively capture GraphQL bookmark responses.
// Does NOT make any additional network requests.

(function () {
  'use strict';

  // Operations we want to capture
  const TARGET_OPS = new Set([
    'Bookmarks',
    'BookmarksAllDelete_mutation',  // Track deletions too
  ]);

  // Parse the operation name from a GraphQL URL
  function parseGraphQLUrl(url: string): { queryId: string; operationName: string } | null {
    const match = url.match(/\/graphql\/([^/]+)\/([^?]+)/);
    if (!match) return null;
    return { queryId: match[1], operationName: match[2] };
  }

  function isGraphQL(url: string): boolean {
    return url.includes('/i/api/graphql');
  }

  // Emit captured data to the content script via CustomEvent
  function emit(operationName: string, queryId: string, url: string, body: string): void {
    window.dispatchEvent(
      new CustomEvent('bm:graphql', {
        detail: { operationName, queryId, url, body },
      })
    );
  }

  // --- Patch fetch ---
  const originalFetch = window.fetch;

  window.fetch = function (input: RequestInfo | URL, init?: RequestInit): Promise<Response> {
    const url =
      typeof input === 'string'
        ? input
        : input instanceof URL
          ? input.href
          : (input as Request).url || '';

    const promise = originalFetch.apply(this, arguments as any);

    if (!isGraphQL(url)) return promise;

    const parsed = parseGraphQLUrl(url);
    if (!parsed || !TARGET_OPS.has(parsed.operationName)) return promise;

    const { operationName, queryId } = parsed;

    // Clone the response and read it asynchronously — never block the page
    promise
      .then((response: Response) => {
        const clone = response.clone();
        clone
          .text()
          .then((text: string) => {
            if (text.length > 0 && text[0] === '{') {
              emit(operationName, queryId, url, text);
            }
          })
          .catch(() => {});
      })
      .catch(() => {});

    return promise;
  };

  // --- Patch XMLHttpRequest (fallback) ---
  const origOpen = XMLHttpRequest.prototype.open;
  const origSend = XMLHttpRequest.prototype.send;

  XMLHttpRequest.prototype.open = function (method: string, url: string | URL) {
    (this as any)._bmUrl = typeof url === 'string' ? url : url.toString();
    return origOpen.apply(this, arguments as any);
  };

  XMLHttpRequest.prototype.send = function () {
    const url: string = (this as any)._bmUrl || '';
    if (isGraphQL(url)) {
      const parsed = parseGraphQLUrl(url);
      if (parsed && TARGET_OPS.has(parsed.operationName)) {
        const { operationName, queryId } = parsed;
        this.addEventListener('load', function () {
          try {
            const text = this.responseText;
            if (text.length > 0 && text[0] === '{') {
              emit(operationName, queryId, url, text);
            }
          } catch (_) {}
        });
      }
    }
    return origSend.apply(this, arguments as any);
  };
})();

Full implementation: response parser

// parser.ts — Parse bookmark GraphQL responses into clean tweet objects

interface ParsedBookmark {
  id: string;
  text: string;
  authorHandle: string;
  authorName: string;
  authorFollowers: number;
  authorVerified: boolean;
  createdAt: string;
  url: string;
  metrics: {
    likes: number;
    retweets: number;
    replies: number;
    quotes: number;
    bookmarks: number;
    views: number;
  };
  media: Array<{
    url: string;
    type: 'photo' | 'video' | 'animated_gif';
  }>;
  urls: Array<{
    expanded: string;
    display: string;
  }>;
  quotedTweet?: ParsedBookmark;
  isReply: boolean;
  inReplyToId?: string;
}

function parseBookmarkResponse(responseText: string): {
  tweets: ParsedBookmark[];
  bottomCursor: string | null;
} {
  const json = JSON.parse(responseText);
  const instructions =
    json.data?.bookmark_timeline_v2?.timeline?.instructions ?? [];

  const addEntries = instructions.find(
    (i: any) => i.type === 'TimelineAddEntries'
  );
  if (!addEntries?.entries) {
    return { tweets: [], bottomCursor: null };
  }

  const tweets: ParsedBookmark[] = [];
  let bottomCursor: string | null = null;

  for (const entry of addEntries.entries) {
    // Handle cursor entries
    if (entry.content?.cursorType === 'Bottom') {
      bottomCursor = entry.content.value;
      continue;
    }

    // Handle tweet entries
    const tweetResult = entry.content?.itemContent?.tweet_results?.result;
    if (!tweetResult || tweetResult.__typename !== 'Tweet') continue;

    const parsed = parseTweetResult(tweetResult);
    if (parsed) tweets.push(parsed);
  }

  return { tweets, bottomCursor };
}

function parseTweetResult(result: any): ParsedBookmark | null {
  try {
    const legacy = result.legacy;
    if (!legacy) return null;

    // User data — Twitter moved fields between core and legacy
    const userResult = result.core?.user_results?.result;
    const screenName =
      userResult?.core?.screen_name ??
      userResult?.legacy?.screen_name ??
      'unknown';
    const name =
      userResult?.core?.name ??
      userResult?.legacy?.name ??
      screenName;
    const followers = userResult?.legacy?.followers_count ?? 0;
    const verified =
      userResult?.is_blue_verified ??
      userResult?.legacy?.verified ??
      false;

    // Media
    const media: ParsedBookmark['media'] = [];
    if (legacy.entities?.media) {
      for (const m of legacy.entities.media) {
        media.push({
          url: m.media_url_https,
          type: m.type as 'photo' | 'video' | 'animated_gif',
        });
      }
    }
    // Extended media for videos
    if (legacy.extended_entities?.media) {
      for (const m of legacy.extended_entities.media) {
        if (m.type === 'video' || m.type === 'animated_gif') {
          const variants = m.video_info?.variants ?? [];
          const best = variants
            .filter((v: any) => v.content_type === 'video/mp4')
            .sort((a: any, b: any) => (b.bitrate ?? 0) - (a.bitrate ?? 0))[0];
          if (best) {
            media.push({ url: best.url, type: m.type });
          }
        }
      }
    }

    // URLs
    const urls: ParsedBookmark['urls'] = [];
    if (legacy.entities?.urls) {
      for (const u of legacy.entities.urls) {
        urls.push({ expanded: u.expanded_url, display: u.display_url });
      }
    }

    // Quoted tweet (recursive)
    let quotedTweet: ParsedBookmark | undefined;
    if (result.quoted_status_result?.result) {
      quotedTweet =
        parseTweetResult(result.quoted_status_result.result) ?? undefined;
    }

    return {
      id: result.rest_id,
      text: legacy.full_text,
      authorHandle: screenName,
      authorName: name,
      authorFollowers: followers,
      authorVerified: verified,
      createdAt: legacy.created_at,
      url: `https://x.com/${screenName}/status/${result.rest_id}`,
      metrics: {
        likes: legacy.favorite_count ?? 0,
        retweets: legacy.retweet_count ?? 0,
        replies: legacy.reply_count ?? 0,
        quotes: legacy.quote_count ?? 0,
        bookmarks: legacy.bookmark_count ?? 0,
        views: parseInt(result.views?.count ?? '0', 10),
      },
      media,
      urls,
      quotedTweet,
      isReply: !!legacy.in_reply_to_status_id_str,
      inReplyToId: legacy.in_reply_to_status_id_str,
    };
  } catch {
    return null;
  }
}

Extension manifest (Manifest V3)

{
  "manifest_version": 3,
  "name": "Twitter Bookmark Exporter",
  "version": "1.0.0",
  "description": "Export your Twitter/X bookmarks as JSON, CSV, or Markdown",
  "permissions": ["activeTab", "storage"],
  "content_scripts": [
    {
      "matches": ["https://x.com/*", "https://twitter.com/*"],
      "js": ["interceptor.js"],
      "world": "MAIN",
      "run_at": "document_start"
    },
    {
      "matches": ["https://x.com/*", "https://twitter.com/*"],
      "js": ["content.js"],
      "run_at": "document_idle"
    }
  ],
  "background": {
    "service_worker": "background.js"
  },
  "action": {
    "default_popup": "popup.html"
  },
  "icons": {
    "16": "icons/icon16.png",
    "48": "icons/icon48.png",
    "128": "icons/icon128.png"
  }
}

Critical: The "world": "MAIN" declaration is what makes this work. Without it, your content script runs in the ISOLATED world and cannot see Twitter’s fetch calls. This was added in Chrome 102 for Manifest V3 extensions. In Manifest V2, you had to inject a <script> tag manually.

Content script bridge

// content.ts — ISOLATED world, bridges MAIN world events to background

const allBookmarks: any[] = [];

// Listen for intercepted GraphQL data from MAIN world
window.addEventListener('bm:graphql', ((event: CustomEvent) => {
  const { operationName, body } = event.detail;

  if (operationName === 'Bookmarks') {
    try {
      const { tweets, bottomCursor } = parseBookmarkResponse(body);
      allBookmarks.push(...tweets);

      // Forward to background script for storage
      chrome.runtime.sendMessage({
        type: 'BOOKMARKS_BATCH',
        tweets,
        totalCount: allBookmarks.length,
        hasMore: !!bottomCursor,
      });

      // Update badge with count
      chrome.runtime.sendMessage({
        type: 'UPDATE_BADGE',
        count: allBookmarks.length,
      });
    } catch (err) {
      console.error('[bookmark-exporter] Parse error:', err);
    }
  }
}) as EventListener);

// Listen for export commands from popup
chrome.runtime.onMessage.addListener((message, _sender, sendResponse) => {
  if (message.type === 'GET_BOOKMARKS') {
    sendResponse({ bookmarks: allBookmarks });
  }
  if (message.type === 'EXPORT_JSON') {
    downloadJSON(allBookmarks);
    sendResponse({ success: true });
  }
  if (message.type === 'EXPORT_CSV') {
    downloadCSV(allBookmarks);
    sendResponse({ success: true });
  }
  if (message.type === 'EXPORT_MARKDOWN') {
    downloadMarkdown(allBookmarks);
    sendResponse({ success: true });
  }
  return true; // Keep channel open for async response
});

function downloadJSON(bookmarks: any[]): void {
  const blob = new Blob([JSON.stringify(bookmarks, null, 2)], {
    type: 'application/json',
  });
  const url = URL.createObjectURL(blob);
  const a = document.createElement('a');
  a.href = url;
  a.download = `twitter-bookmarks-${new Date().toISOString().split('T')[0]}.json`;
  a.click();
  URL.revokeObjectURL(url);
}

function downloadCSV(bookmarks: any[]): void {
  const headers = [
    'id', 'url', 'author_handle', 'author_name', 'text',
    'created_at', 'likes', 'retweets', 'replies', 'views',
  ];
  const rows = bookmarks.map((b) =>
    headers.map((h) => {
      const val =
        h === 'url' ? b.url :
        h === 'author_handle' ? b.authorHandle :
        h === 'author_name' ? b.authorName :
        h === 'text' ? b.text :
        h === 'created_at' ? b.createdAt :
        h === 'likes' ? b.metrics?.likes :
        h === 'retweets' ? b.metrics?.retweets :
        h === 'replies' ? b.metrics?.replies :
        h === 'views' ? b.metrics?.views :
        b[h] ?? '';
      return `"${String(val).replace(/"/g, '""')}"`;
    }).join(',')
  );
  const csv = [headers.join(','), ...rows].join('\n');
  const blob = new Blob([csv], { type: 'text/csv' });
  const url = URL.createObjectURL(blob);
  const a = document.createElement('a');
  a.href = url;
  a.download = `twitter-bookmarks-${new Date().toISOString().split('T')[0]}.csv`;
  a.click();
  URL.revokeObjectURL(url);
}

function downloadMarkdown(bookmarks: any[]): void {
  const lines = bookmarks.map((b) => {
    const date = new Date(b.createdAt).toISOString().split('T')[0];
    const metrics = `${b.metrics.likes}L ${b.metrics.retweets}RT ${b.metrics.views}V`;
    return [
      `## [@${b.authorHandle}](https://x.com/${b.authorHandle}) — ${date}`,
      '',
      b.text,
      '',
      `[Link](${b.url}) | ${metrics}`,
      b.media.length > 0
        ? b.media.map((m: any) => `![](${m.url})`).join('\n')
        : '',
      '',
      '---',
      '',
    ].filter(Boolean).join('\n');
  });
  const md = `# Twitter Bookmarks Export\n\nExported: ${new Date().toISOString()}\nTotal: ${bookmarks.length} bookmarks\n\n---\n\n${lines.join('\n')}`;
  const blob = new Blob([md], { type: 'text/markdown' });
  const url = URL.createObjectURL(blob);
  const a = document.createElement('a');
  a.href = url;
  a.download = `twitter-bookmarks-${new Date().toISOString().split('T')[0]}.md`;
  a.click();
  URL.revokeObjectURL(url);
}

Gotchas

1. Twitter uses fetch, not XHR — Patching only XMLHttpRequest will miss most requests on modern Twitter. Always patch both.
2. Response cloning — You must response.clone() before reading. If you consume the original response body, Twitter’s app will break.
3. document_start timing — The interceptor must load before Twitter’s JavaScript. If it loads late, early requests slip through.
4. Rate limiting — Twitter rate-limits the Bookmarks GraphQL endpoint at roughly 500 requests per 15 minutes. Normal scrolling will not hit this, but programmatic rapid-fire requests will.
5. Schema drift — Twitter moves fields between core and legacy objects without warning. In March 2026, screen_name moved from user_results.result.legacy to user_results.result.core. Your parser needs fallback paths.

Reference implementation

The gold standard for this approach is prinsss/twitter-web-exporter (3,400+ stars). It runs as a Tampermonkey userscript and supports bookmarks, likes, tweets, lists, and media download. It uses the same GraphQL interception pattern described here but packages it as a userscript instead of a Chrome extension.

The quick-and-dirty approach. Read tweet text directly from the rendered DOM. No network interception, no API calls. Works in the DevTools console with zero setup.

How it works

1. Navigate to x.com/i/bookmarks
2. A MutationObserver watches for new DOM nodes
3. As tweets render, querySelectorAll('[data-testid="tweetText"]') extracts tweet text
4. window.scrollBy(0, 5000) triggers Twitter’s infinite scroll to load more tweets
5. When the tweet count is unchanged for 2+ scroll cycles, export is complete

Full implementation: console script

This is based on the gd3kr gist, the most widely shared bookmark export script:

// Paste this into DevTools console on x.com/i/bookmarks
// Scrolls through all bookmarks, captures tweet data, downloads as JSON

(function exportBookmarks() {
  const tweets = [];
  const seenIds = new Set();
  let previousCount = 0;
  let unchangedCount = 0;
  let scrollCount = 0;

  // Extract data from a tweet article element
  function parseTweetElement(article) {
    const tweetText = article.querySelector('[data-testid="tweetText"]');
    const userLink = article.querySelector(
      'a[role="link"][href*="/"]'
    );
    const time = article.querySelector('time');

    // Extract handle from link href
    let handle = '';
    if (userLink) {
      const href = userLink.getAttribute('href');
      if (href && href.startsWith('/')) {
        handle = href.split('/')[1];
      }
    }

    // Extract metrics from aria-labels
    const likeButton = article.querySelector(
      '[data-testid="like"]'
    );
    const retweetButton = article.querySelector(
      '[data-testid="retweet"]'
    );
    const replyButton = article.querySelector(
      '[data-testid="reply"]'
    );

    function getMetric(button) {
      if (!button) return 0;
      const label = button.getAttribute('aria-label') || '';
      const match = label.match(/(\d[\d,]*)/);
      return match ? parseInt(match[1].replace(/,/g, ''), 10) : 0;
    }

    // Build tweet URL from handle + status link
    let tweetUrl = '';
    const statusLink = article.querySelector(
      'a[href*="/status/"]'
    );
    if (statusLink) {
      tweetUrl = 'https://x.com' + statusLink.getAttribute('href');
    }

    // Extract tweet ID from URL
    let tweetId = '';
    if (tweetUrl) {
      const idMatch = tweetUrl.match(/\/status\/(\d+)/);
      if (idMatch) tweetId = idMatch[1];
    }

    return {
      id: tweetId,
      text: tweetText ? tweetText.innerText : '',
      handle: handle,
      url: tweetUrl,
      timestamp: time ? time.getAttribute('datetime') : '',
      likes: getMetric(likeButton),
      retweets: getMetric(retweetButton),
      replies: getMetric(replyButton),
    };
  }

  // MutationObserver to catch new tweets as they render
  const observer = new MutationObserver((mutations) => {
    for (const mutation of mutations) {
      if (!mutation.addedNodes.length) continue;

      const articles = document.querySelectorAll(
        'article[data-testid="tweet"]'
      );
      for (const article of articles) {
        const parsed = parseTweetElement(article);
        if (parsed.id && !seenIds.has(parsed.id)) {
          seenIds.add(parsed.id);
          tweets.push(parsed);
        }
      }
    }
  });

  observer.observe(document.body, { childList: true, subtree: true });

  // Also capture any tweets already on the page
  const existing = document.querySelectorAll(
    'article[data-testid="tweet"]'
  );
  for (const article of existing) {
    const parsed = parseTweetElement(article);
    if (parsed.id && !seenIds.has(parsed.id)) {
      seenIds.add(parsed.id);
      tweets.push(parsed);
    }
  }

  console.log(`[bookmark-export] Starting scroll. Initial tweets: ${tweets.length}`);

  // Auto-scroll interval
  const scrollInterval = setInterval(() => {
    window.scrollBy(0, 5000);
    scrollCount++;

    console.log(
      `[bookmark-export] Scroll #${scrollCount} — ${tweets.length} tweets captured`
    );

    if (tweets.length === previousCount) {
      unchangedCount++;
      if (unchangedCount >= 3) {
        clearInterval(scrollInterval);
        observer.disconnect();

        console.log(
          `[bookmark-export] Done! ${tweets.length} tweets captured in ${scrollCount} scrolls.`
        );

        // Download as JSON
        const blob = new Blob(
          [JSON.stringify(tweets, null, 2)],
          { type: 'application/json' }
        );
        const url = URL.createObjectURL(blob);
        const a = document.createElement('a');
        a.href = url;
        a.download = `bookmarks-${Date.now()}.json`;
        document.body.appendChild(a);
        a.click();
        document.body.removeChild(a);
        URL.revokeObjectURL(url);
      }
    } else {
      unchangedCount = 0;
    }

    previousCount = tweets.length;
  }, 2000);

  // Safety: expose stop function
  window.__stopBookmarkExport = function () {
    clearInterval(scrollInterval);
    observer.disconnect();
    console.log(
      `[bookmark-export] Manually stopped. ${tweets.length} tweets captured.`
    );
    return tweets;
  };

  console.log(
    '[bookmark-export] Running. Call window.__stopBookmarkExport() to stop early.'
  );
})();

Enhanced version with richer DOM extraction

The basic tweetText approach misses media, quoted tweets, and thread context. Here is an enhanced parser:

function parseEnhancedTweetElement(article) {
  // Basic fields
  const base = parseTweetElement(article);

  // Images
  const images = [];
  const imgElements = article.querySelectorAll(
    '[data-testid="tweetPhoto"] img'
  );
  for (const img of imgElements) {
    const src = img.getAttribute('src');
    if (src && src.includes('pbs.twimg.com')) {
      // Get original quality
      images.push(src.replace(/&name=\w+/, '&name=orig'));
    }
  }

  // Video presence (cannot get URL from DOM alone)
  const hasVideo = article.querySelector(
    '[data-testid="videoPlayer"]'
  ) !== null;

  // Quoted tweet
  let quotedTweet = null;
  const quotedArticle = article.querySelector(
    '[data-testid="quoteTweet"]'
  );
  if (quotedArticle) {
    const quotedText = quotedArticle.querySelector(
      '[data-testid="tweetText"]'
    );
    const quotedUser = quotedArticle.querySelector(
      'a[role="link"][href*="/"]'
    );
    quotedTweet = {
      text: quotedText ? quotedText.innerText : '',
      handle: quotedUser
        ? quotedUser.getAttribute('href')?.split('/')[1] ?? ''
        : '',
    };
  }

  // Thread indicator
  const isThread = article.querySelector(
    '[data-testid="tweet-text-show-more-link"]'
  ) !== null;

  // Display name (not just handle)
  let displayName = '';
  const nameSpan = article.querySelector(
    'a[role="link"] span'
  );
  if (nameSpan) {
    displayName = nameSpan.textContent || '';
  }

  return {
    ...base,
    displayName,
    images,
    hasVideo,
    quotedTweet,
    isThread,
  };
}

Limitations

Key insight: DOM scraping is the fastest way to get started but produces the poorest data. You get tweet text and basic metrics. GraphQL interception gives you the full tweet object including media URLs, view counts, entity metadata, and exact timestamps.

Reference implementations

• sahil-lalani/bookmark-export (450+ stars) — Chrome extension using DOM scraping
• gd3kr/948296cf675469f5028911f8eb276dbc — The original console gist
• ShreyaPrasad1209/Export-Twitter-bookmarks-in-markdown — DevTools + Python for Markdown output

The legitimate approach. Uses Twitter’s v2 API endpoint GET /2/users/:id/bookmarks. Requires OAuth 2.0 PKCE. Costs $200/month minimum. Returns at most 800 bookmarks.

Setup requirements

1. Developer account at developer.x.com
2. Basic tier ($200/month) — The Free tier does not include bookmark access
3. OAuth 2.0 app with scopes: tweet.read, users.read, bookmark.read
4. PKCE flow — Bookmarks are user-context-only; app-only tokens do not work

OAuth 2.0 PKCE flow

// oauth.ts — Twitter OAuth 2.0 Authorization Code with PKCE

import crypto from 'crypto';

const CLIENT_ID = process.env.TWITTER_CLIENT_ID!;
const REDIRECT_URI = 'http://localhost:3000/callback';

// Step 1: Generate PKCE challenge
function generatePKCE(): { codeVerifier: string; codeChallenge: string } {
  const codeVerifier = crypto.randomBytes(32).toString('base64url');
  const codeChallenge = crypto
    .createHash('sha256')
    .update(codeVerifier)
    .digest('base64url');
  return { codeVerifier, codeChallenge };
}

// Step 2: Build authorization URL
function getAuthorizationUrl(codeChallenge: string, state: string): string {
  const params = new URLSearchParams({
    response_type: 'code',
    client_id: CLIENT_ID,
    redirect_uri: REDIRECT_URI,
    scope: 'tweet.read users.read bookmark.read offline.access',
    state,
    code_challenge: codeChallenge,
    code_challenge_method: 'S256',
  });
  return `https://twitter.com/i/oauth2/authorize?${params}`;
}

// Step 3: Exchange code for token
async function exchangeCodeForToken(
  code: string,
  codeVerifier: string
): Promise<{ access_token: string; refresh_token: string }> {
  const response = await fetch('https://api.twitter.com/2/oauth2/token', {
    method: 'POST',
    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
    body: new URLSearchParams({
      code,
      grant_type: 'authorization_code',
      client_id: CLIENT_ID,
      redirect_uri: REDIRECT_URI,
      code_verifier: codeVerifier,
    }),
  });

  if (!response.ok) {
    throw new Error(`Token exchange failed: ${response.status} ${await response.text()}`);
  }

  return response.json();
}

// Step 4: Refresh token (tokens expire in 2 hours)
async function refreshAccessToken(
  refreshToken: string
): Promise<{ access_token: string; refresh_token: string }> {
  const response = await fetch('https://api.twitter.com/2/oauth2/token', {
    method: 'POST',
    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
    body: new URLSearchParams({
      refresh_token: refreshToken,
      grant_type: 'refresh_token',
      client_id: CLIENT_ID,
    }),
  });

  if (!response.ok) {
    throw new Error(`Token refresh failed: ${response.status}`);
  }

  return response.json();
}

Fetching bookmarks with pagination

// bookmarks-api.ts — Fetch bookmarks via official Twitter API v2

interface TwitterApiBookmark {
  id: string;
  text: string;
  created_at: string;
  author_id: string;
  public_metrics: {
    retweet_count: number;
    reply_count: number;
    like_count: number;
    quote_count: number;
    bookmark_count: number;
    impression_count: number;
  };
  entities?: {
    urls?: Array<{ expanded_url: string; display_url: string }>;
    mentions?: Array<{ username: string }>;
  };
}

interface BookmarksResponse {
  data: TwitterApiBookmark[];
  includes?: {
    users: Array<{ id: string; username: string; name: string }>;
  };
  meta: {
    result_count: number;
    next_token?: string;
  };
}

async function fetchAllBookmarks(
  accessToken: string,
  userId: string
): Promise<TwitterApiBookmark[]> {
  const allBookmarks: TwitterApiBookmark[] = [];
  let paginationToken: string | undefined;
  let pageCount = 0;

  const tweetFields = [
    'created_at',
    'public_metrics',
    'entities',
    'author_id',
    'context_annotations',
  ].join(',');

  const expansions = 'author_id';
  const userFields = 'username,name,profile_image_url,verified';

  do {
    const params = new URLSearchParams({
      'tweet.fields': tweetFields,
      expansions,
      'user.fields': userFields,
      max_results: '100', // Maximum per page
    });

    if (paginationToken) {
      params.set('pagination_token', paginationToken);
    }

    const url = `https://api.twitter.com/2/users/${userId}/bookmarks?${params}`;

    const response = await fetch(url, {
      headers: { Authorization: `Bearer ${accessToken}` },
    });

    if (response.status === 429) {
      // Rate limited — wait and retry
      const resetTime = response.headers.get('x-rate-limit-reset');
      const waitMs = resetTime
        ? (parseInt(resetTime, 10) * 1000 - Date.now()) + 1000
        : 60_000;
      console.log(`Rate limited. Waiting ${Math.ceil(waitMs / 1000)}s...`);
      await new Promise((resolve) => setTimeout(resolve, waitMs));
      continue; // Retry same page
    }

    if (!response.ok) {
      throw new Error(`API error: ${response.status} ${await response.text()}`);
    }

    const body: BookmarksResponse = await response.json();

    if (body.data) {
      allBookmarks.push(...body.data);
    }

    paginationToken = body.meta?.next_token;
    pageCount++;

    console.log(
      `Page ${pageCount}: ${body.data?.length ?? 0} bookmarks ` +
      `(total: ${allBookmarks.length})`
    );

    // Small delay to be respectful
    await new Promise((resolve) => setTimeout(resolve, 500));
  } while (paginationToken);

  return allBookmarks;
}

Limitations

Reference implementations

• xdevplatform/export-bookmarks — Official Twitter sample, Flask + OAuth 2.0
• nornagon/twitter-bookmark-archiver — Node.js, downloads media, generates HTML viewer

Key insight: The official API is the “correct” way to export bookmarks, but it is also the worst option for most people. $200/month for a maximum of 800 tweets, with less data per tweet than the GraphQL interception method gets for free. The API exists primarily for businesses building Twitter integrations, not for personal bookmark export.

The power user approach. Combine GraphQL interception with a local database (IndexedDB or SQLite) to build a persistent, searchable bookmark archive that survives across browser sessions.

How Twillot works

Twillot is the most sophisticated open-source bookmark manager. It uses GraphQL interception to capture bookmarks, stores them in IndexedDB, and provides folder management, search, and AI-powered categorization.

Architecture:

Browser (x.com)
  └─ MAIN world interceptor ─── captures GraphQL responses
       └─ Content script bridge
            └─ Background service worker
                 └─ IndexedDB (local storage)
                      ├─ tweets table
                      ├─ folders table
                      ├─ tags table (AI-generated)
                      └─ sync_state table

Building your own local archive

// db.ts — IndexedDB storage for captured bookmarks

const DB_NAME = 'bookmark-archive';
const DB_VERSION = 2;

interface StoredBookmark {
  id: string;               // Tweet ID (primary key)
  text: string;
  authorHandle: string;
  authorName: string;
  createdAt: string;        // Original tweet timestamp
  capturedAt: string;       // When we captured it
  url: string;
  metrics: {
    likes: number;
    retweets: number;
    replies: number;
    views: number;
    bookmarks: number;
  };
  media: Array<{ url: string; type: string }>;
  folder?: string;          // User-assigned folder
  tags?: string[];          // AI-generated tags
  notes?: string;           // User annotations
  raw?: string;             // Full GraphQL response for this tweet
}

function openDB(): Promise<IDBDatabase> {
  return new Promise((resolve, reject) => {
    const request = indexedDB.open(DB_NAME, DB_VERSION);

    request.onupgradeneeded = (event) => {
      const db = (event.target as IDBOpenDBRequest).result;

      if (!db.objectStoreNames.contains('bookmarks')) {
        const store = db.createObjectStore('bookmarks', { keyPath: 'id' });
        store.createIndex('authorHandle', 'authorHandle', { unique: false });
        store.createIndex('capturedAt', 'capturedAt', { unique: false });
        store.createIndex('folder', 'folder', { unique: false });
      }

      if (!db.objectStoreNames.contains('sync_state')) {
        db.createObjectStore('sync_state', { keyPath: 'key' });
      }
    };

    request.onsuccess = () => resolve(request.result);
    request.onerror = () => reject(request.error);
  });
}

async function upsertBookmarks(bookmarks: StoredBookmark[]): Promise<number> {
  const db = await openDB();
  const tx = db.transaction('bookmarks', 'readwrite');
  const store = tx.objectStore('bookmarks');
  let upserted = 0;

  for (const bookmark of bookmarks) {
    // Merge with existing data (preserve user annotations)
    const existing = await new Promise<StoredBookmark | undefined>(
      (resolve) => {
        const req = store.get(bookmark.id);
        req.onsuccess = () => resolve(req.result);
        req.onerror = () => resolve(undefined);
      }
    );

    const merged: StoredBookmark = existing
      ? {
          ...bookmark,
          folder: existing.folder ?? bookmark.folder,
          tags: existing.tags ?? bookmark.tags,
          notes: existing.notes,
          capturedAt: existing.capturedAt, // Keep original capture time
        }
      : { ...bookmark, capturedAt: new Date().toISOString() };

    store.put(merged);
    upserted++;
  }

  await new Promise<void>((resolve, reject) => {
    tx.oncomplete = () => resolve();
    tx.onerror = () => reject(tx.error);
  });

  db.close();
  return upserted;
}

async function searchBookmarks(
  query: string,
  options?: {
    folder?: string;
    author?: string;
    limit?: number;
    offset?: number;
  }
): Promise<StoredBookmark[]> {
  const db = await openDB();
  const tx = db.transaction('bookmarks', 'readonly');
  const store = tx.objectStore('bookmarks');
  const results: StoredBookmark[] = [];

  return new Promise((resolve) => {
    const cursor = store.openCursor();
    let skipped = 0;

    cursor.onsuccess = (event) => {
      const result = (event.target as IDBRequest<IDBCursorWithValue>).result;
      if (!result) {
        db.close();
        resolve(results);
        return;
      }

      const bookmark: StoredBookmark = result.value;
      let matches = true;

      // Text search (simple substring)
      if (query && !bookmark.text.toLowerCase().includes(query.toLowerCase())) {
        matches = false;
      }

      // Folder filter
      if (options?.folder && bookmark.folder !== options.folder) {
        matches = false;
      }

      // Author filter
      if (
        options?.author &&
        bookmark.authorHandle.toLowerCase() !== options.author.toLowerCase()
      ) {
        matches = false;
      }

      if (matches) {
        if (options?.offset && skipped < options.offset) {
          skipped++;
        } else {
          results.push(bookmark);
        }
      }

      if (options?.limit && results.length >= options.limit) {
        db.close();
        resolve(results);
        return;
      }

      result.continue();
    };
  });
}

async function getBookmarkCount(): Promise<number> {
  const db = await openDB();
  const tx = db.transaction('bookmarks', 'readonly');
  const store = tx.objectStore('bookmarks');

  return new Promise((resolve) => {
    const countReq = store.count();
    countReq.onsuccess = () => {
      db.close();
      resolve(countReq.result);
    };
  });
}

async function exportAll(
  format: 'json' | 'csv' | 'markdown'
): Promise<string> {
  const db = await openDB();
  const tx = db.transaction('bookmarks', 'readonly');
  const store = tx.objectStore('bookmarks');

  const all: StoredBookmark[] = await new Promise((resolve) => {
    const req = store.getAll();
    req.onsuccess = () => resolve(req.result);
  });

  db.close();

  switch (format) {
    case 'json':
      return JSON.stringify(all, null, 2);
    case 'csv':
      return bookmarksToCsv(all);
    case 'markdown':
      return bookmarksToMarkdown(all);
  }
}

Folder management

// folders.ts — Organize bookmarks into user-defined folders

async function assignFolder(
  bookmarkIds: string[],
  folder: string
): Promise<void> {
  const db = await openDB();
  const tx = db.transaction('bookmarks', 'readwrite');
  const store = tx.objectStore('bookmarks');

  for (const id of bookmarkIds) {
    const req = store.get(id);
    req.onsuccess = () => {
      const bookmark = req.result;
      if (bookmark) {
        bookmark.folder = folder;
        store.put(bookmark);
      }
    };
  }

  await new Promise<void>((resolve, reject) => {
    tx.oncomplete = () => resolve();
    tx.onerror = () => reject(tx.error);
  });

  db.close();
}

async function getFolders(): Promise<Array<{ name: string; count: number }>> {
  const db = await openDB();
  const tx = db.transaction('bookmarks', 'readonly');
  const store = tx.objectStore('bookmarks');
  const folderCounts = new Map<string, number>();

  return new Promise((resolve) => {
    const cursor = store.openCursor();
    cursor.onsuccess = (event) => {
      const result = (event.target as IDBRequest<IDBCursorWithValue>).result;
      if (!result) {
        db.close();
        resolve(
          Array.from(folderCounts.entries())
            .map(([name, count]) => ({ name, count }))
            .sort((a, b) => b.count - a.count)
        );
        return;
      }
      const folder = result.value.folder ?? 'Uncategorized';
      folderCounts.set(folder, (folderCounts.get(folder) ?? 0) + 1);
      result.continue();
    };
  });
}

AI categorization (optional)

// categorize.ts — Use an LLM to auto-tag bookmarks

async function categorizeBookmarks(
  bookmarks: StoredBookmark[],
  apiKey: string
): Promise<Map<string, string[]>> {
  const results = new Map<string, string[]>();

  // Batch bookmarks to reduce API calls (20 per batch)
  const batches: StoredBookmark[][] = [];
  for (let i = 0; i < bookmarks.length; i += 20) {
    batches.push(bookmarks.slice(i, i + 20));
  }

  for (const batch of batches) {
    const tweetSummaries = batch.map(
      (b, i) => `[${i}] @${b.authorHandle}: ${b.text.slice(0, 200)}`
    ).join('\n');

    const response = await fetch('https://api.openai.com/v1/chat/completions', {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        Authorization: `Bearer ${apiKey}`,
      },
      body: JSON.stringify({
        model: 'gpt-4o-mini',
        messages: [
          {
            role: 'system',
            content: `Categorize tweets into 1-3 tags each. Return JSON: {"results": [{"index": 0, "tags": ["tag1", "tag2"]}]}. Use lowercase tags like: programming, ai, business, design, career, writing, productivity, humor, news, science, crypto, startup.`,
          },
          { role: 'user', content: tweetSummaries },
        ],
        response_format: { type: 'json_object' },
        max_tokens: 1000,
      }),
    });

    const json = await response.json();
    const content = JSON.parse(json.choices[0].message.content);

    for (const result of content.results) {
      const bookmark = batch[result.index];
      if (bookmark) {
        results.set(bookmark.id, result.tags);
      }
    }

    // Rate limit courtesy
    await new Promise((r) => setTimeout(r, 500));
  }

  return results;
}

Reference implementation

• twillot-app/twillot — Full-featured bookmark manager with folders, search, and AI tags

The zero-install approach. Paste code into DevTools or install a Tampermonkey userscript. No extension, no API keys, no developer account.

Console paste-and-run

The simplest possible export — paste this into DevTools while on x.com/i/bookmarks:

// Minimal bookmark export — paste into DevTools console
// Captures tweet text only (no metrics, no media)

const tweets = [];
const seen = new Set();

const observer = new MutationObserver(() => {
  document.querySelectorAll('[data-testid="tweetText"]').forEach((el) => {
    const text = el.innerText;
    if (!seen.has(text)) {
      seen.add(text);
      tweets.push(text);
    }
  });
});

observer.observe(document.body, { childList: true, subtree: true });

const scroll = setInterval(() => {
  window.scrollBy(0, 5000);
  console.log(`Captured: ${tweets.length}`);
}, 2000);

// Run this when done scrolling:
// clearInterval(scroll); observer.disconnect();
// copy(JSON.stringify(tweets, null, 2));