Bulk Unsubscribe From YouTube Channels in Small Batches

To bulk unsubscribe from YouTube channels, first decide whether you need automation at all. YouTube’s documented workflow removes subscriptions individually; a browser script can repeat interface actions, but its selectors can break when the page changes.

For a handful of channels, I would use the manual controls. For a larger cleanup, start by inspecting a small batch rather than handing an unbounded loop access to the whole list.

Bulk unsubscribe from YouTube channels in small batches

Open YouTube’s subscription manager while signed in to the intended account. Check that the list contains the channels you mean to remove.

The script below starts in DRY_RUN mode. It lists the matching buttons without clicking them:

(async () => {
  const DRY_RUN = true;
  const LIMIT = 1;
  const DELAY_MS = 1500;
  const wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
  const visible = (element) => element.getClientRects().length > 0;
  const text = (element) => element.textContent.trim().toLowerCase();
  const selector =
    "ytd-subscription-notification-toggle-button-renderer-next > yt-button-shape > button";
  const buttons = [...document.querySelectorAll(selector)]
    .filter(visible)
    .slice(0, LIMIT);

  if (!buttons.length) {
    console.warn("No matching subscription buttons. Stop and inspect the page.");
    return;
  }

  console.table(buttons.map((button, index) => ({
    number: index + 1,
    label: button.getAttribute("aria-label") || button.textContent.trim(),
  })));

  if (DRY_RUN) return;
  if (!window.confirm(`Attempt to remove up to ${buttons.length} subscriptions?`)) return;

  window.stopYouTubeUnsubscribe = false;
  let confirmations = 0;

  try {
    for (const button of buttons) {
      if (window.stopYouTubeUnsubscribe) break;
      if (!button.isConnected || !visible(button)) {
        throw new Error("A subscription button changed. Stop and reload the list.");
      }

      button.click();
      await wait(DELAY_MS);
      if (window.stopYouTubeUnsubscribe) break;

      const items = [...document.querySelectorAll(
        "ytd-menu-service-item-renderer, [role='menuitem']"
      )].filter((item) => visible(item) && text(item) === "unsubscribe");
      const uniqueItems = items.filter((item) =>
        !items.some((other) => other !== item && item.contains(other))
      );
      if (uniqueItems.length !== 1) {
        throw new Error("Expected one visible Unsubscribe menu item.");
      }
      uniqueItems[0].click();
      await wait(DELAY_MS);
      if (window.stopYouTubeUnsubscribe) break;

      const confirmButtons = [...document.querySelectorAll(
        "ytd-confirm-dialog-renderer #confirm-button button, " +
        "yt-confirm-dialog-renderer #confirm-button button"
      )].filter((item) => visible(item) && !item.disabled && text(item) === "unsubscribe");
      if (confirmButtons.length !== 1) {
        throw new Error("Expected one visible Unsubscribe confirmation button.");
      }
      confirmButtons[0].click();
      confirmations++;
      console.log(`Confirmation clicked: ${confirmations}`);
      await wait(DELAY_MS);
    }
  } catch (error) {
    console.error("Stopped:", error.message);
  }
})();

This is an experimental example for the English interface, not a verified current YouTube integration. The control flow was exercised against a local test interface; the selectors were not validated by removing subscriptions from a live account.

The subscription-button selector comes from the earlier version of this article. If YouTube now uses different markup, the example needs deliberate adaptation before it can work.

Read the dry run before enabling clicks

Open Developer Tools, select Console, and read the script before pasting it. Code executed there runs in the page’s context. Chrome’s self-XSS guidance explains why the browser may warn about pasted scripts.

With DRY_RUN = true, inspect the listed button and its surrounding channel row. A matching selector does not prove that the button belongs to a channel you want to remove.

For a deliberate single-channel trial, change DRY_RUN to false and leave LIMIT at 1. The script asks for confirmation before starting the interface actions.

After the attempt, inspect the subscription list itself. A logged confirmation click is not proof that YouTube accepted the change. A request can fail after the interface has received a click.

Only increase the limit after understanding the result. A batch such as five channels is easier to inspect than a loop that keeps loading and removing entries until something fails.

Stop rather than guessing at a changed menu

The script looks for one visible English Unsubscribe menu item, then one confirmation button. It stops if it cannot identify a unique control.

The waits only give the interface time to update. They do not guarantee that a menu will be ready, and increasing a delay cannot repair a changed selector.

To request a stop between the next interface steps, run:

window.stopYouTubeUnsubscribe = true;

A stop flag cannot undo a click that already happened. Reloading the page ends this page script too, but actions already accepted by YouTube remain account changes.

The example processes only the matching, visible buttons found at the start. It does not automatically scroll through the whole account. Scroll and review the next batch yourself before running it again.

Keep the manual route available

YouTube’s unsubscribe instructions describe opening a channel’s video, choosing Subscribed, and then Unsubscribe. The subscription manager is useful for reviewing the wider list, while the documented per-channel route gives you an alternative if its layout changes.

Unsubscribing does not create a local backup of the list. Note the channels you may want to revisit before running a batch. YouTube also notes that unsubscribing and subscribing again resets notification settings, so re-subscribing is not an exact undo.

For a tool that needs a maintained integration, the YouTube Data API subscriptions.delete method is the documented endpoint. It requires authorization and subscription IDs; it is not an unauthenticated shortcut to somebody’s account.

Browser automation can save clicks, but it adds a maintenance job. For an occasional cleanup, keeping each batch small makes that trade-off much easier to justify.

← Back to all articles