// findChannels.js
// Parallelized server scanning to find chattable channels.
// Uses servers.json (auto-located).
// WARNING: Selfbots violate Discord TOS. Use at your own risk.
const { Client, Intents } = require('discord.js-selfbot-v13');
const fs = require('fs');
const path = require('path');
/////////// CONFIG ///////////
const TOKEN = ''; // <-- put your token here
// Concurrency settings (tune to be slower to avoid rate limits/bans).
const CONCURRENCY = 1; // Set to 1 to process servers one by one (safer)
const CHANNEL_TEST_DELAY_MS = 2000; // Delay between testing each channel (in ms, e.g., 2000 = 2 seconds)
const RETRY_ATTEMPTS = 3; // retry attempts on transient errors / 429
const RETRY_BASE_MS = 1000; // base backoff in ms
const TEST_SEND = true; // Enabled to actually test sending "X" and deleting it to verify chattable (RISKY: can trigger anti-spam, rate limits, or bans! Run on small server lists first.)
const LOG_CHANNELS = true; // Enabled to log each found/verified channel's name and ID to console
const INTENTS = [Intents.FLAGS.GUILDS, Intents.FLAGS.GUILD_MEMBERS];
/////////// HELPERS ///////////
function sleep(ms) { return new Promise(res => setTimeout(res, ms)); }
/**
* Locate servers.json in several sensible places so doubled folder problems won't block you.
*/
function locateServersJson() {
const candidates = [
path.resolve(process.cwd(), 'servers.json'),
path.join(__dirname, 'servers.json'),
];
for (const p of candidates) if (fs.existsSync(p)) return p;
return { notFound: true, attempted: candidates };
}
function loadServerIdsOrExit() {
const located = locateServersJson();
if (located && located.notFound) {
console.error('[error] Required file not found. Attempted the following paths:');
for (const p of located.attempted) console.error(' ' + p);
console.error('\nCreate a servers.json in one of those locations using this format (array of guild ID strings):');
console.error(`[\n "349051257702580224",\n "587355301083349002",\n "1141515589924429869"\n]`);
process.exit(1);
}
console.log(`[info] Using servers.json at: ${located}`);
let parsed;
try { parsed = JSON.parse(fs.readFileSync(located, 'utf8')); }
catch (e) { console.error(`[error] Failed to parse ${located}: ${e.message}`); process.exit(1); }
if (!Array.isArray(parsed)) { console.error(`[error] ${located} must contain a JSON array of guild ID strings.`); process.exit(1); }
const ids = Array.from(new Set(parsed.map(String).map(s => s.trim()).filter(Boolean).filter(s => /^\d+$/.test(s))));
if (!ids.length) { console.error(`[error] ${located} contains no valid numeric guild IDs.`); process.exit(1); }
return ids;
}
/**
* Generic limited-concurrency runner.
* items: array
* limit: number of parallel workers
* worker: async function(item, index) -> result
*/
async function runLimited(items, limit, worker) {
let i = 0;
const results = new Array(items.length);
const workers = Array.from({ length: Math.min(limit, items.length) }, async () => {
while (true) {
const idx = i++;
if (idx >= items.length) break;
try { results[idx] = await worker(items[idx], idx); }
catch (err) { results[idx] = { __error: err }; }
}
});
await Promise.all(workers);
return results;
}
/**
* Robust channel scan inside a guild.
* Tries to fetch channels and check permissions with retries on errors.
* If TEST_SEND is true, actually tries to send and delete a message to verify.
* Skips threads as per user request.
*/
async function findChattableChannelsInGuildWithRetries(guild, client) {
for (let attempt = 0; attempt < RETRY_ATTEMPTS; attempt++) {
try {
// Fetch self member
const me = await guild.members.fetch(client.user.id);
// Fetch all channels (cache should populate) - only gets channels visible to the user
await guild.channels.fetch();
const channels = guild.channels.cache;
const chattable = [];
for (const channel of channels.values()) {
if (!channel.isText() || channel.isThread()) continue; // Skip non-text and threads
// Check permission first
if (!channel.permissionsFor(me).has('SEND_MESSAGES')) continue;
if (TEST_SEND) {
// Actually test send "X" and delete
try {
const msg = await channel.send('X');
await msg.delete();
chattable.push(channel.id);
if (LOG_CHANNELS) console.log(` - Verified by send: #${channel.name} (${channel.id})`);
} catch (sendErr) {
console.warn(`[warn] Cannot send in channel ${channel.id} (${channel.name}): ${sendErr.message || sendErr}`);
continue;
}
} else {
chattable.push(channel.id);
if (LOG_CHANNELS) console.log(` - Found (perm check): #${channel.name} (${channel.id})`);
}
// Delay between channel tests to avoid rate limits
await sleep(CHANNEL_TEST_DELAY_MS);
}
return chattable;
} catch (err) {
// Detect 429-like behavior if possible
const is429 = (err && (err.status === 429 || /429|Too Many Requests/i.test(err.message || '')));
const waitMs = RETRY_BASE_MS * Math.pow(2, attempt);
if (is429) {
console.warn(`[warn] Rate limited in guild ${guild.id}. Backing off ${waitMs}ms (attempt ${attempt+1}/${RETRY_ATTEMPTS})`);
} else {
console.warn(`[warn] Error in guild ${guild.id}: ${err.message || err}. Retrying ${waitMs}ms (attempt ${attempt+1}/${RETRY_ATTEMPTS})`);
}
await sleep(waitMs);
}
}
// All attempts failed -> treat as no channels for this guild
return [];
}
/////////// MAIN ///////////
(async () => {
if (!TOKEN || TOKEN === 'PASTE_YOUR_TOKEN_HERE') {
console.error('No token provided. Paste your token into the TOKEN constant at top of the script.');
process.exit(1);
}
const serverIds = loadServerIdsOrExit();
console.log(`Loaded ${serverIds.length} server ID(s) from servers.json.`);
console.log(`Using concurrency: CONCURRENCY=${CONCURRENCY} (lowered for safety)`);
console.log(`TEST_SEND mode: ${TEST_SEND ? 'ENABLED (will try sending "X" in each channel - risky, but verifies truly chattable)' : 'DISABLED (permission check only)'}`);
console.log(`CHANNEL_TEST_DELAY_MS: ${CHANNEL_TEST_DELAY_MS}ms between each channel test`);
console.log(`LOG_CHANNELS: ${LOG_CHANNELS ? 'ENABLED' : 'DISABLED'}`);
const client = new Client({ intents: INTENTS });
client.once('ready', async () => {
console.log(`\nLogged in as ${client.user.tag}`);
const allChattableChannels = new Set(); // Use set to avoid duplicates
// Process servers in parallel with CONCURRENCY
await runLimited(serverIds, CONCURRENCY, async (sid, idx) => {
console.log(`\n[${idx+1}/${serverIds.length}] Checking server ${sid} ...`);
let guild;
try {
guild = await client.guilds.fetch(sid);
} catch (err) {
console.warn(`- Skipping guild ${sid}: cannot fetch (not in guild / invalid id).`);
return;
}
try {
const channels = await findChattableChannelsInGuildWithRetries(guild, client);
if (channels.length) {
console.log(`- Found ${channels.length} chattable channel(s) in ${guild.name} (${guild.id})`);
channels.forEach(id => allChattableChannels.add(id));
} else {
console.log(`- No chattable channels found in ${guild.name} (${guild.id})`);
}
} catch (err) {
console.warn(`- Error scanning guild ${sid}: ${err.message || err}`);
}
});
// Write to channels.json
const outputPath = path.resolve(process.cwd(), 'channels.json');
const channelArray = Array.from(allChattableChannels).sort(); // Sort for consistency
const jsonContent = '[\n' + channelArray.map(id => ` "${id}"`).join(',\n') + '\n]';
fs.writeFileSync(outputPath, jsonContent, 'utf8');
console.log(`\n--- scan complete — summary ---`);
console.log(`Found ${channelArray.length} chattable channel(s) across all servers.`);
console.log(`Saved to: ${outputPath}`);
client.destroy();
process.exit(0);
});
client.on('error', (err) => {
console.error('Client error:', err && err.message ? err.message : err);
});
try {
await client.login(TOKEN);
} catch (err) {
console.error('Failed to login:', err && err.message ? err.message : err);
process.exit(1);
}
})();
