chaodonghu · September 19, 2026 17:22 · nkre · Feb 27, 2021 · chaodonghu · Feb 28, 2021
diff --git a/follow-instagram.js b/follow-instagram.js
 // Run GOOGLE CHROME - WORKING AS OF SEPTEMBER 19 2026
 // Please @ me in the comments if this stops working, I will try to get it working again within the month
 //
 // INSTRUCTIONS
 // 1. Open Instagram in Chrome
 // 2. Click on "followers" on any Instagram profile so the followers list opens
 // 3. Right click the page, click "INSPECT", open the "Console" tab
 // 4. Paste this script and press enter
 // 5. Keep the tab focused. Chrome throttles timers in background tabs.
 //    Open it in its own window and leave it on screen.
 // 6. Run `stopFollow = true` in the console to stop early
 //
 // The script clicks Follow on the first unfollowed user in the list, confirms
 // the button flipped to Following or Requested, scrolls to load more when the
 // list runs out, and repeats.
 //
 // RATE LIMITS
 // Instagram does not publish its limits. Follows are policed harder than
 // likes or unfollows. Community-reported estimates for established accounts
 // are roughly 100 to 200 follows per day and 20 to 30 per hour. New or
 // previously flagged accounts get less. Going over triggers an action block
 // that can last days, so the defaults below sit under those estimates. Lower
 // them if you get blocked. Re-run the script each day; it remembers what it
 // did in the last 24 hours via localStorage.

 const followEveryone = (async () => {
  const DAILY_LIMIT = 100;            // per rolling 24h. Estimate, see above.
  const HOURLY_LIMIT = 20;            // per rolling 1h.  Estimate, see above.
  const MIN_WAIT = 120_000;           // ms between follows
  const MAX_WAIT = 240_000;           // ~3 min avg lands right at the hourly cap
  const UI_TIMEOUT = 3_000;           // how long to wait for the UI to update
  const STORAGE_KEY = "igFollowLog";

  const HOUR = 60 * 60_000;
  const DAY = 24 * HOUR;

  const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
  const rand = (min, max) => Math.round(min + Math.random() * (max - min));
  const fmt = (ms) => new Date(ms).toLocaleTimeString();

  // Scope to the followers dialog so we never hit the profile header's Follow button.
  const scope = () => document.querySelector('div[role="dialog"]') || document;
  const buttons = () => [...scope().querySelectorAll("button")];
  const findFollowButton = () =>
    buttons().find((b) => ["Follow", "Follow Back"].includes(b.innerText.trim()));

  const waitFor = async (predicate, timeout) => {
    const end = Date.now() + timeout;
    while (Date.now() < end) {
      const result = predicate();
      if (result) return result;
      await sleep(100);
    }
    return null;
  };

  // Timestamps of follows in the last 24h, persisted across reloads.
  const loadLog = () => {
    try {
      const cutoff = Date.now() - DAY;
      return JSON.parse(localStorage.getItem(STORAGE_KEY) || "[]").filter((t) => t > cutoff);
    } catch {
      return [];
    }
  };
  const saveLog = (log) => localStorage.setItem(STORAGE_KEY, JSON.stringify(log));
  const inWindow = (log, ms) => log.filter((t) => t > Date.now() - ms);

  // The list is lazy loaded. Scroll the last row into view to fetch more.
  const loadMore = async () => {
    const all = buttons();
    all[all.length - 1]?.scrollIntoView({ block: "end" });
    return waitFor(findFollowButton, UI_TIMEOUT);
  };

  window.stopFollow = false;
  const log = loadLog();
  let sessionCount = 0;

  console.log(`Starting. ${log.length}/${DAILY_LIMIT} used in the last 24h.`);

  while (!window.stopFollow) {
    // Daily cap: stop and say when to come back.
    const today = inWindow(log, DAY);
    if (today.length >= DAILY_LIMIT) {
      console.log(`Daily limit reached. Run again after ${fmt(today[0] + DAY)}.`);
      break;
    }

    // Hourly cap: sleep until the oldest follow in the window ages out.
    const hour = inWindow(log, HOUR);
    if (hour.length >= HOURLY_LIMIT) {
      const resumeAt = hour[0] + HOUR + 1000;
      console.log(`Hourly limit reached. Resuming at ${fmt(resumeAt)}.`);
      await sleep(resumeAt - Date.now());
      continue;
    }

    let followBtn = findFollowButton();
    if (!followBtn) {
      followBtn = await loadMore();
      if (!followBtn) {
        console.log("No more users to follow.");
        break;
      }
    }

    followBtn.scrollIntoView({ block: "center" });
    followBtn.click();

    // Confirm the follow registered. Public accounts flip to Following,
    // private ones to Requested. Only count it if the button changed.
    const changed = await waitFor(
      () => !followBtn.isConnected || !["Follow", "Follow Back"].includes(followBtn.innerText.trim()),
      UI_TIMEOUT
    );
    if (!changed) {
      console.log("Follow did not register, retrying after a short wait.");
      await sleep(5000);
      continue;
    }

    log.push(Date.now());
    saveLog(log);
    sessionCount++;
    console.log(`Followed #${sessionCount} this session (${log.length}/${DAILY_LIMIT} today)`);

    const wait = rand(MIN_WAIT, MAX_WAIT);
    console.log(`Waiting ${Math.round(wait / 1000)}s`);
    await sleep(wait);
  }

  console.log(`Done. Followed ${sessionCount} this session, ${log.length} in the last 24h.`);
 })();
	// Run GOOGLE CHROME - WORKING AS OF SEPTEMBER 19 2026
	// Please @ me in the comments if this stops working, I will try to get it working again within the month
	//
	// INSTRUCTIONS
	// 1. Open Instagram in Chrome
	// 2. Click on "followers" on any Instagram profile so the followers list opens
	// 3. Right click the page, click "INSPECT", open the "Console" tab
	// 4. Paste this script and press enter
	// 5. Keep the tab focused. Chrome throttles timers in background tabs.
	// Open it in its own window and leave it on screen.
	// 6. Run `stopFollow = true` in the console to stop early
	//
	// The script clicks Follow on the first unfollowed user in the list, confirms
	// the button flipped to Following or Requested, scrolls to load more when the
	// list runs out, and repeats.
	//
	// RATE LIMITS
	// Instagram does not publish its limits. Follows are policed harder than
	// likes or unfollows. Community-reported estimates for established accounts
	// are roughly 100 to 200 follows per day and 20 to 30 per hour. New or
	// previously flagged accounts get less. Going over triggers an action block
	// that can last days, so the defaults below sit under those estimates. Lower
	// them if you get blocked. Re-run the script each day; it remembers what it
	// did in the last 24 hours via localStorage.

	const followEveryone = (async () => {
	const DAILY_LIMIT = 100; // per rolling 24h. Estimate, see above.
	const HOURLY_LIMIT = 20; // per rolling 1h. Estimate, see above.
	const MIN_WAIT = 120_000; // ms between follows
	const MAX_WAIT = 240_000; // ~3 min avg lands right at the hourly cap
	const UI_TIMEOUT = 3_000; // how long to wait for the UI to update
	const STORAGE_KEY = "igFollowLog";

	const HOUR = 60 * 60_000;
	const DAY = 24 * HOUR;

	const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
	const rand = (min, max) => Math.round(min + Math.random() * (max - min));
	const fmt = (ms) => new Date(ms).toLocaleTimeString();

	// Scope to the followers dialog so we never hit the profile header's Follow button.
	const scope = () => document.querySelector('div[role="dialog"]') \|\| document;
	const buttons = () => [...scope().querySelectorAll("button")];
	const findFollowButton = () =>
	buttons().find((b) => ["Follow", "Follow Back"].includes(b.innerText.trim()));

	const waitFor = async (predicate, timeout) => {
	const end = Date.now() + timeout;
	while (Date.now() < end) {
	const result = predicate();
	if (result) return result;
	await sleep(100);
	}
	return null;
	};

	// Timestamps of follows in the last 24h, persisted across reloads.
	const loadLog = () => {
	try {
	const cutoff = Date.now() - DAY;
	return JSON.parse(localStorage.getItem(STORAGE_KEY) \|\| "[]").filter((t) => t > cutoff);
	} catch {
	return [];
	}
	};
	const saveLog = (log) => localStorage.setItem(STORAGE_KEY, JSON.stringify(log));
	const inWindow = (log, ms) => log.filter((t) => t > Date.now() - ms);

	// The list is lazy loaded. Scroll the last row into view to fetch more.
	const loadMore = async () => {
	const all = buttons();
	all[all.length - 1]?.scrollIntoView({ block: "end" });
	return waitFor(findFollowButton, UI_TIMEOUT);
	};

	window.stopFollow = false;
	const log = loadLog();
	let sessionCount = 0;

	console.log(`Starting. ${log.length}/${DAILY_LIMIT} used in the last 24h.`);

	while (!window.stopFollow) {
	// Daily cap: stop and say when to come back.
	const today = inWindow(log, DAY);
	if (today.length >= DAILY_LIMIT) {
	console.log(`Daily limit reached. Run again after ${fmt(today[0] + DAY)}.`);
	break;
	}

	// Hourly cap: sleep until the oldest follow in the window ages out.
	const hour = inWindow(log, HOUR);
	if (hour.length >= HOURLY_LIMIT) {
	const resumeAt = hour[0] + HOUR + 1000;
	console.log(`Hourly limit reached. Resuming at ${fmt(resumeAt)}.`);
	await sleep(resumeAt - Date.now());
	continue;
	}

	let followBtn = findFollowButton();
	if (!followBtn) {
	followBtn = await loadMore();
	if (!followBtn) {
	console.log("No more users to follow.");
	break;
	}
	}

	followBtn.scrollIntoView({ block: "center" });
	followBtn.click();

	// Confirm the follow registered. Public accounts flip to Following,
	// private ones to Requested. Only count it if the button changed.
	const changed = await waitFor(
	() => !followBtn.isConnected \|\| !["Follow", "Follow Back"].includes(followBtn.innerText.trim()),
	UI_TIMEOUT
	);
	if (!changed) {
	console.log("Follow did not register, retrying after a short wait.");
	await sleep(5000);
	continue;
	}

	log.push(Date.now());
	saveLog(log);
	sessionCount++;
	console.log(`Followed #${sessionCount} this session (${log.length}/${DAILY_LIMIT} today)`);

	const wait = rand(MIN_WAIT, MAX_WAIT);
	console.log(`Waiting ${Math.round(wait / 1000)}s`);
	await sleep(wait);
	}

	console.log(`Done. Followed ${sessionCount} this session, ${log.length} in the last 24h.`);
	})();
No results found