How to Delete Multiple Tweets at Once for free (No Tools, Just your browser)

To delete multiple tweets at once without any third-party tools, open your X profile in a desktop browser, press F12 to open the developer console, and paste a script that clicks the "more" menu, "Delete," and "Confirm" — for every tweet, at machine speed, with built-in rate-limit recovery. But here is the part almost nobody tells you: X has never had a bulk-delete feature. There is no official way to delete all tweets at once, there never has been, and every "delete all tweets" tool on the internet — free or paid — is a workaround around that absence. This method is the only one where your login never leaves your own browser. Welcome back to our Security/Privacy series..

That absence — the missing bulk-delete button — is the entire reason this guide exists, and it is worth being blunt about why. X (formerly Twitter) lets you delete one tweet at a time through the interface: click the "more" icon, click Delete, click Confirm. Three clicks, maybe five seconds, per tweet. For someone with 500 tweets, that is 40 minutes of mechanical clicking. For someone with 10,000 tweets, it is thirteen hours. X has never added a "select all and delete" option, and the workaround ecosystem — browser extensions, web apps that ask for your login, desktop programs — exists entirely to fill that gap.

The method in this guide fills the same gap differently: a script you paste into your browser's own developer console, which automates the exact same three-click delete flow the interface provides, using your own logged-in session. No credentials are shared with anyone. No extension is installed. No website receives your password. The script below is optimized for maximum sustained throughput — it uses DOM polling instead of fixed delays, removes deleted tweets from the page locally so the next one is instantly available, and includes adaptive rate-limit recovery so it never needs you to manually refresh mid-session.

Before You Delete Anything: Download Your Archive

This step is not optional, and it comes before any script, any console, any deletion. Once a tweet is deleted, it is gone from your account permanently — X does not offer an undo, a recycle bin, or a grace period. If you delete 3,000 tweets and then remember that one of them was the only record of something you cared about, there is no recovery path.

X provides a full archive of your data as a built-in feature:

1. Go to Settings and privacy (click your profile picture → Settings and privacy).
2. Click Your account.
3. Click Download an archive of your data.
4. Verify your password when prompted.
5. Confirm your request.

X then prepares the archive — this can take anywhere from minutes to a couple of days depending on account size and their queue — and sends you a notification and email when it is ready. The download is a ZIP file containing every tweet you have ever posted (in a machine-readable JSON file), along with your direct messages, media, profile information, and more.

How Tweet Deletion Actually Works (and Why There Is No Bulk Button)

The official deletion flow — the one the interface provides and the one this method automates — is three steps:

1. On any of your own tweets, click the more icon (the three dots or caret in the tweet's corner).
2. Click Delete in the menu that appears.
3. Click Delete again in the confirmation dialog.

Three clicks. That is the entire official mechanism, and X has never wrapped it in a bulk interface — no checkbox multi-select, no "delete all from this month," no "wipe everything before 2020." Whether this is a design choice (deletion friction as engagement protection), a legal consideration (deleted tweets disappearing from lawsuits and journalistic records), or simple product prioritization, the result is the same: anyone wanting to remove more than a handful of tweets has to either do it manually or find a workaround.

What the console method does is automate those three clicks — but intelligently. Instead of blind fixed delays between actions (which are either too slow or too fast depending on your connection), the script below uses DOM polling: it checks every 50 milliseconds whether the menu has rendered, and moves the instant it appears. On a fast connection, that means the menu click happens in 50-100ms instead of a fixed 400ms wait. Over 10,000 tweets, that difference compounds into hours saved.

The Fastest Console Script: Full Walkthrough

Everything below happens in your browser. You need a desktop browser — Chrome, Edge, Firefox, or Safari — on a computer, not a phone. Mobile browsers either hide the console entirely or make it unusable for this purpose.

Step 1: Open your profile

Log in to X and navigate to your own profile page — the URL will be x.com/yourusername. You should see your tweets displayed in the timeline, the same view any visitor to your profile sees.

If you want to delete tweets from a specific period, this is where you filter: X's advanced search (search for from:yourusername until:2020-01-01, for example) can show you tweets from before a date. However, the script below works on whatever tweets are visible on the current page — so for now, just be on your profile with tweets loaded.

Step 2: Open the developer console

Press F12 on Windows, or Cmd + Option + I on Mac. A panel opens — usually docked to the bottom or right of the browser window. This is the developer console: a tool built into every browser that lets you inspect and interact with the page's code.

Click the Console tab at the top of this panel. You will see a text prompt at the bottom — this is where the script goes.

Step 3: Paste the script

Here is the script. Read it before running it — every line is explained below.

(async () => {
  const sleep = ms => new Promise(r => setTimeout(r, ms));

  // Poll for an element instead of waiting a fixed time —
  // grabs it the millisecond it renders, not a millisecond later
  const waitFor = async (selector, timeout = 3000) => {
    const start = Date.now();
    while (Date.now() - start < timeout) {
      const el = document.querySelector(selector);
      if (el) return el;
      await sleep(50);
    }
    return null;
  };

  const startTime = Date.now();
  let deleted = 0, skipped = 0, emptyRounds = 0;
  let rateLimitHits = 0, lastRateLimit = 0;

  // Remove the tweet element locally so the next one
  // is instantly available — zero scrolling between deletes
  const removeLocally = (tweet) =>
    tweet.closest('[data-testid="cellInnerDiv"]')?.remove();

  console.log('%c⚡ MAX SPEED MODE ACTIVE', 'color: #00ff88; font-size: 14px; font-weight: bold;');

  while (true) {
    // Scope INSIDE the tweet article — never grabs
    // the profile header or navigation "More" buttons
    const tweet = document.querySelector('article[data-testid="tweet"]');

    if (!tweet) {
      emptyRounds++;
      window.scrollBy(0, 2000);
      await sleep(1000);
      if (emptyRounds > 10) {
        const mins = Math.round((Date.now() - startTime) / 60000);
        console.log('✅ Finished: ' + deleted + ' deleted, ' + skipped + ' skipped in ' + mins + ' min');
        break;
      }
      continue;
    }
    emptyRounds = 0;

    const caret = tweet.querySelector('[data-testid="caret"]');
    if (!caret) { removeLocally(tweet); skipped++; continue; }

    try {
      // 1. Click the caret — poll for the menu to appear
      caret.click();
      const menu = await waitFor('[role="menuitem"]', 2000);

      if (!menu) {
        // Menu didn't appear — rate-limited. Back off and retry.
        rateLimitHits++;
        lastRateLimit = Date.now();
        const waitTime = Math.min(15 * rateLimitHits, 120);
        console.log('⏳ Rate limit #' + rateLimitHits + ' — waiting ' + waitTime + 's...');
        document.body.click();
        await sleep(waitTime * 1000);
        continue; // Retry this tweet, don't skip it
      }

      // 2. Find Delete option — menu is already open, this is instant
      const deleteOption = Array.from(
        document.querySelectorAll('[role="menuitem"]')
      ).find(el => el.textContent.includes('Delete'));

      if (deleteOption) {
        deleteOption.click();
        // Poll for the confirm button — as fast as it renders
        const confirmBtn = await waitFor('[data-testid="confirmationSheetConfirm"]', 3000);

        if (confirmBtn) {
          confirmBtn.click();
          deleted++;
          removeLocally(tweet); // Next tweet is already in the DOM

          // Adaptive cooldown: fast when clean, slower after rate limits
          const recentLimit = Date.now() - lastRateLimit < 120000;
          const cooldown = recentLimit ? 1500 : 700;
          await sleep(cooldown);

          if (deleted % 100 === 0) {
            const rate = Math.round(deleted / ((Date.now() - startTime) / 3600000));
            console.log('⚡ ' + deleted + ' deleted | Running at ~' + rate + '/hr');
          }
        } else {
          // Confirm never appeared — harder rate limit
          rateLimitHits++;
          lastRateLimit = Date.now();
          console.log('⏳ Hard rate limit — waiting 60s...');
          document.body.click();
          await sleep(60000);
        }
      } else {
        // Repost or non-deletable — remove and move on instantly
        document.body.click();
        removeLocally(tweet);
        skipped++;
        await sleep(100);
      }
    } catch (err) {
      document.body.click();
      removeLocally(tweet);
      skipped++;
      await sleep(300);
    }
  }
})();

What makes this the fastest version

Three optimizations separate this from every other console script circulating on Reddit and forums:

• DOM polling instead of fixed delays. Other scripts wait a fixed 400-600ms for the dropdown menu to appear after clicking the caret. This script checks every 50ms and grabs the menu the instant it renders — typically 50-150ms on a decent connection. That difference compounds: over 5,000 tweets, saving 300ms per menu-wait alone saves 25 minutes.
• Local element removal after each delete. Other scripts scroll the page between deletions or wait for X to re-render the timeline. This script removes the deleted tweet's element from the local DOM immediately — the next tweet is already loaded and becomes the "first" tweet instantly. Zero scroll time, zero re-render wait, zero page jumping.
• Adaptive rate-limit recovery. Instead of a fixed "safe" speed that is always too slow, the script runs at maximum speed (700ms between deletions) and only slows down when X actually pushes back. When it detects a rate limit (the menu or confirm button fails to appear), it waits progressively longer — 15s, then 30s, then 45s — and automatically returns to full speed after two minutes of clean operation. You never need to manually refresh or restart.

The result: approximately 4,000 deletions per hour when running clean, with automatic slowdowns to ~2,400/hour during rate-limit recovery periods. A 10,000-tweet account clears in about 3-4 hours with minimal babysitting.

What each part does, in plain English

• The wrapper (async () => { ... }) — runs everything as a sequence that can pause between steps.
• The polling function (waitFor) — instead of waiting a fixed time and hoping the element appeared, this checks every 50ms and returns the moment it finds the element. If the element never appears within the timeout, it returns null (which the script treats as a rate-limit signal).
• The loop (while (true)) — keeps going until there are no tweets left.
• Finding the tweet (article[data-testid="tweet"]) — X builds each tweet as an "article" element with a specific test identifier. This is how the script sees tweets the same way your eyes do.
• Opening the menu ([data-testid="caret"]) — the caret is the "more options" icon on each tweet. The script scopes this lookup inside the tweet element, so it can never accidentally grab the "More" button in the page navigation or profile header.
• Clicking Delete — looks through the open menu for the item whose text contains "Delete" and clicks it.
• Confirming ([data-testid="confirmationSheetConfirm"]) — polls for the confirmation button and clicks it the instant it renders.
• Removing locally (removeLocally) — after confirming, the tweet element is removed from the local page. The next tweet in the timeline is already loaded in the DOM and instantly becomes the "first" tweet for the next loop iteration. This is why the script does not scroll between deletions — it does not need to.
• The adaptive cooldown — 700ms between deletions normally; 1500ms if there was a rate limit in the last two minutes. This keeps the script at maximum speed when X is cooperating and automatically backs off when it is not.
• Rate limit recovery — when the menu fails to appear (the first symptom of rate limiting), the script waits progressively longer (15s × the number of hits, capped at 120s) and then retries the same tweet. No manual intervention needed.
• Throughput reporting — every 100 deletions, the console shows the running count and the actual calculated rate (tweets per hour), so you always know how fast you are going and how long the rest will take.

Step 4: Run it and watch

Paste the script into the console and press Enter. The console prints "⚡ MAX SPEED MODE ACTIVE" and the page starts moving on its own: menus opening, Delete being clicked, confirmations flashing, tweets vanishing. Every 100 deletions, you get a speed report.

Do not close the tab or navigate away while the script is running. The script lives in that tab's context; navigating or closing stops it instantly. You can let it run in the background while you do other things in other tabs or windows — just leave the profile tab alone.

Speed expectation at a glance:

Step 5: Stopping the script

To stop at any point: press F12 to focus the console (if it is not already), then click inside the console area and press Ctrl + C (or Cmd + . on Mac). This sends an interrupt that halts the loop. Alternatively, simply close the tab — abrupt, but effective.

Whatever has been deleted is deleted — stopping the script does not undo anything. Whatever has not been deleted remains, and you can restart the script later (refresh the page first, then re-paste).

What Deletion Actually Removes (and What It Does Not)

This is the section people skip and later wish they had not. Deleting a tweet removes it from X — from your profile, from your followers' timelines, from X search, from hashtag pages. That part is thorough and permanent. But "deleted from X" is not the same as "deleted from the internet," and the gap between those two things is wider than most people expect.

The honest takeaway: deleting tweets cleans your profile, which is what most people actually want — the public face of their account, refreshed. It does not perform a digital exorcism. If the goal is "my old takes stop being the first thing people see when they search my name," deletion accomplishes that. If the goal is "this text never existed anywhere," deletion cannot promise that, and nothing can.

Retweets, Likes, and Replies: What the Script Handles and Skips

The script deletes tweets — your original posts and your replies. It deliberately skips retweets and does not touch your Likes tab.

Retweets: a retweet on your profile has "Undo Repost" in the menu, not "Delete." The script looks for "Delete" text and skips anything that does not have it — reposts are removed from the local DOM and counted as skipped, so the loop advances without stalling. To clear retweets, un-repost them manually (one click each — the fast case where manual is fine).

Likes: your Likes tab shows tweets you have liked from other people. These are not your tweets and cannot be "deleted" — they are unliked, one click each. There is no bulk unlike in the interface.

Replies: your replies to other people's tweets ARE your tweets, and they appear on your profile's timeline. The script handles them the same as original posts — the Delete option is present in their menus. One caution: deleting a reply removes it from the conversation thread on the original tweet too.

Pinned tweets: a pinned tweet has an "Unpin from profile" option instead of (or alongside) Delete in its menu. The practical workaround is to unpin manually before running the script, then re-pin whatever you are keeping.

The Manual Method: Fast Enough for Small Jobs

For fewer than about 50 tweets, the console script is arguably overkill — the setup and monitoring take longer than just deleting them by hand. The manual flow, at its fastest:

1. Open your profile.
2. On a tweet, click the more icon.
3. Click Delete.
4. Click the red Delete button in the confirmation.
5. The next tweet moves up. Repeat.

The rhythm settles into about 3-5 seconds per tweet once you stop reading each one. Fifty tweets is roughly four minutes. The breaking point where the script becomes worth the setup is somewhere around 100-200 tweets.

The Nuclear Option: Deleting Your Account (and What It Actually Does)

Does deleting your Twitter account delete your tweets? This is one of the most-searched questions on the topic, and the answer has more layers than people expect.

Deactivation versus deletion: when you "delete" your X account, what actually happens first is deactivation. X describes the process as: you initiate deletion, your account is deactivated immediately (invisible to other users, your handle unresolvable), and after a 30-day window of no login, the account and its data are permanently deleted. Log back in during those 30 days and the deletion is canceled — the account reactivates as if nothing happened.

Is deactivating the same as deleting? No — deactivation is the first phase of deletion, not a separate lighter option. It looks identical from the outside (account gone, tweets unviewable), but it is reversible for 30 days. After 30 days, it becomes true deletion, which is not reversible.

After permanent deletion: your tweets, followers, likes, and DMs are removed from X's systems. But — connecting back to the earlier section — anything archived elsewhere (Wayback Machine, screenshots, third-party databases that scraped tweets) persists. Deleting the account removes the source, not the copies that were already made.

The nuclear option makes sense when you want the account, the handle, and everything attached to it gone — not when you want to clean up your tweet history while keeping the account.

Troubleshooting: When the Script Acts Up

Problem 1: Rate limit messages appearing frequently

Symptom: The console shows "⏳ Rate limit #3 — waiting 45s..." every few minutes.

Cause: X is throttling your deletion speed. The script detects this automatically and backs off, but if it keeps happening, the base cooldown is too aggressive for your account's current standing.

Fix: The script handles this itself — the adaptive cooldown increases after each rate limit hit and recovers after two minutes of clean operation. If rate limits are happening every few tweets, stop the script, wait 30 minutes, and restart. Newer accounts and accounts that have recently been flagged for automation tend to hit rate limits faster.

Problem 2: The script stops finding tweets partway down the profile

Symptom: The console shows scrolling happening but no "Deleted" messages — the script is scrolling without finding new tweets to process.

Cause: X's infinite scroll stops loading — the page sometimes fails to fetch the next batch of tweets, especially on very long profiles or flaky connections.

Fix: The script tries scrolling ten times before giving up. If it stops, manually scroll down the profile until more tweets load (or refresh and navigate back to where you left off), then restart the script. For very large profiles, expect to restart a few times.

Problem 3: "Why will Twitter not delete my tweets?" — stuck tweets

Cause: A few specific things create undeletable-in-the-normal-flow tweets: the pinned tweet (needs unpinning first), tweets currently in a "limit reached" state, and tweets that are part of an active thread you are viewing in a different context.

Fix: Unpin the pinned tweet manually before starting the script. For anything else stuck, try deleting it manually through the regular interface — if the manual Delete works, the script just skipped it; if manual also fails, it is a platform-side issue that waiting usually resolves.

Problem 4: The selectors stopped matching entirely (X updated their UI)

Cause: X is one of the most frequently redesigned interfaces on the internet. The data-testid attributes the script uses are reasonably stable (they exist for X's own automated testing), but they do change occasionally.

Fix: Right-click the "more" icon on any of your tweets and choose "Inspect" — the browser dev tools open with that element highlighted. Look at its attributes: if the data-testid is no longer "caret," you have found the change. Update the corresponding selector in the script. The same process applies to the menu items and the confirmation button.

For the Security-Conscious: Why This Method Is the Safest Option

If you work in security, manage accounts professionally, or simply take credential hygiene seriously, the console method has a property the alternatives do not: nothing leaves your machine.

Compare the trust surface:

1. Browser extensions for tweet deletion — an extension has access to everything on every page you visit, in every tab, all the time. A tweet-deletion extension needs broad page access to do its job, and you are trusting the extension developer (and whoever buys the extension next) with that access indefinitely.
2. Web-based deletion tools — you authenticate through them (via OAuth, ideally, which grants tokens without sharing your password). Those tokens can read and delete your tweets until revoked. You are trusting the service's security, their data handling, their business model, and their future acquisition.
3. Desktop applications — you enter credentials into a program that then acts as you. Full access, stored locally or on their servers depending on implementation, for as long as the token is valid.
4. The console method — a script you can read in full before running, executing in your browser's own context, using your existing logged-in session, touching only the tab you run it in. When you close the tab, it is gone. There is nothing to revoke, nothing to uninstall, and no third party who ever held a token.

This is not to say the third-party tools are malicious — many are legitimate services doing what they advertise. But for the threat model of "I do not want another party holding access to my account," the console method is the only option where the answer is structurally zero rather than trust-dependent.

Frequently Asked Questions

How do I delete all tweets at once for free?

Use the browser console method described in this guide: open your X profile in a desktop browser, press F12, paste the deletion script, and press Enter. The script runs at approximately 4,000 deletions per hour with automatic rate-limit recovery. It is free and requires no third-party tool, extension, or login sharing.

Is there an official way to bulk delete tweets on X?

No. X has never offered a bulk-delete feature. The only official deletion paths are one tweet at a time through the interface, or deleting your entire account. Every bulk-deletion method — including this one and every third-party tool — is a workaround around that absence.

How fast is the console script?

Approximately 4,000 deletions per hour when running without rate limits — roughly one tweet every 900 milliseconds including all pauses and cooldowns. When rate-limited, the script automatically slows to about 2,400/hour and recovers to full speed after two minutes of clean operation. A 10,000-tweet account clears in about 3-4 hours.

Does deleting my Twitter account delete my tweets?

Yes, eventually. Deleting your account first deactivates it (invisible to everyone for 30 days), then permanently removes it along with your tweets, followers, and data. However, tweets already archived by third parties, screenshotted, or indexed by search engines can persist after account deletion.

Is deactivating the same as deleting my Twitter account?

No. Deactivation is the first phase of deletion — your account becomes invisible, but you can restore it by logging back in within 30 days. If you do not log in for 30 days, the account is permanently deleted. Deactivation is reversible; deletion is not.

Can I delete tweets from a specific date range?

The script deletes whatever is visible on your profile, newest first. To target a date range, use X's advanced search (from:yourusername until:2020-01-01) to see which tweets fall in the range, then either delete those manually or let the script run and stop it when it reaches the cutoff point.

How long does it take to delete 10,000 tweets?

With the console script at approximately 4,000 deletions per hour: about 2.5 hours on a clean run, or 3-4 hours with typical rate-limit interruptions. This is significantly faster than the manual method (13+ hours) and competitive with paid third-party tools.

Why will Twitter not delete my tweets?

Common causes: you are trying to delete a pinned tweet (unpin it first), a retweet (use Undo Repost, not Delete), or someone else's tweet (you can only delete your own). If your own unpinned tweet refuses to delete even manually, it is usually a temporary platform issue — wait and retry.

Are tweet deletion browser extensions safe?

Some are, some are not — and the risk profile is structural: a browser extension with page access can read everything on every site you visit. Even a legitimate extension can be sold to a new owner who changes what it does. The console method avoids this entirely: no extension, no persistent access, nothing running after you close the tab.

Does X have an auto-delete feature for old tweets?

X does not offer a built-in auto-delete that removes tweets after a certain age. The closest official capability is deleting manually or through the workaround methods in this guide. Third-party services offer auto-deletion on a schedule, but they hold ongoing access to your account to do it.

Can I undelete a tweet?

No. Tweet deletion is permanent and immediate — there is no trash folder, no undo window, and no support recovery path. This is why downloading your archive before deleting matters: the archive is the only copy that will exist afterward.

Does the console method work on mobile?

No — mobile browsers either do not expose a developer console or make it impractical for pasting and running scripts. You need a desktop browser on a computer.

Will the script delete my retweets too?

No — the script looks for "Delete" in the menu, and retweets have "Undo Repost" instead. Retweets are removed from the local page and skipped, so the loop keeps moving. To clear retweets, un-repost them manually.

How do I delete all my tweets on X for free without giving anyone my password?

The browser console method in this guide is exactly that: it runs in your own browser, uses your existing logged-in session, and no third party ever receives your credentials. Read the script before running it — it only clicks buttons on your own profile.

What happens to retweets and quote tweets when I delete a tweet?

Retweets of your deleted tweet break — they show nothing or disappear. Quote tweets (where someone embedded your tweet in their own comment) remain as posts, but the embedded preview of your tweet typically shows as unavailable or deleted.

Can I run the script overnight?

Yes — the adaptive rate-limit recovery means the script handles interruptions without manual intervention. A 10,000-tweet account can realistically clear overnight: start it before bed, check in the morning. Very large accounts (50,000+) may need a restart or two when the infinite scroll stalls.

Wrapping Up: Your Own Hands, Your Own Machine, at Machine Speed

The three things to take away if you take away nothing else: first, download your archive before deleting anything — deletion is permanent, and the archive is the only record you will ever have. Second, X has no official bulk-delete and never has — every tool and method is a workaround, and the console method is the only one where your credentials stay in your browser. Third, fastest does not mean shortest gap between clicks — it means highest sustained throughput, and the adaptive script is built for sustained: full speed when X cooperates, automatic recovery when it does not.

The console method trades the convenience of paid tools for privacy, cost, and control. It is competitive on speed — 4,000 deletions per hour is genuinely fast — and it asks you to trust nobody but yourself.

Jake deleted his old shop-account tweets one Sunday afternoon — 847 of them, mostly 2019-era complaints about phone suppliers — in about 20 minutes while the football game played in the background. Ethan's verdict: "You just did what a $30 tool would have done, except the $30 tool would still have a token to your account when you were done. Twenty minutes was the price of keeping your keys — and it was a bargain."

Revision note. Written September 2026, covering X (formerly Twitter). But as a word of caution, X redesigns regularly, so expect selectors to need occasional updates when the script stops finding buttons. If you came here with 10,000 tweets and left knowing you can clear them yourself this weekend at 4,000 per hour without handing your login to a stranger — that knowledge is worth more than any tool, and the fact that you chose the method that keeps your credentials to yourself puts you ahead of everyone still pasting passwords into deletion websites. Happy learning!