Discord Thread Management 2026: Archive, Lock, Delete, Bots

Threads pile up fast on a busy server: support questions answered days ago, side chats under announcements, forum posts nobody closed. Discord gives you three tools for them (close, lock and delete) plus a timer that hides quiet threads by itself. This guide covers each one with the menu names from Discord's help center and the limits from its developer documentation, both checked on 3 November 2026, and ends with a small bot that archives threads for you.

Quick answer: To manage Discord threads, open the thread and press the three dots at the top. Close Thread archives it, Edit Thread sets the name, slowmode and Hide After Inactivity (1 hour, 24 hours, 3 days by default, or 1 week), and Delete Thread removes it for good. A closed thread keeps its messages and reopens when someone posts in it, unless a moderator also locked it. A deleted thread cannot be restored, not even by Discord's support team. Moderating threads takes the Manage Threads permission. In a forum, right-click a post and choose Close Post. For rules Discord has no setting for, such as closing support threads after 6 quiet hours, a small bot does the work.

Archive vs Lock vs Delete

The Discord app calls archiving "closing", while the API and bot libraries still say archived. The automatic timer is Hide After Inactivity in the app and auto_archive_duration in the API.

Close and lock usually go together. A thread that is only closed comes back the moment someone replies, which suits a side chat but not a solved support question. Discord's Threads FAQ says that if a moderator closes and locks a thread, only users with moderator permissions can open it again. A locked thread that is still open stays readable, and the developer documentation says members can still react in it, but they cannot post.

Who Can Manage Threads: the Manage Threads Permission

Discord uses four thread permissions (Threads FAQ):

• Send Messages in Threads: post inside threads. The normal Send Messages permission has no effect there.
• Create Public Threads: start threads everyone with access to the channel can see.
• Create Private Threads: start threads only invited people can see.
• Manage Threads: rename, delete, close and open, lock and set slowmode on threads, and view all private threads.

The split between the person who started a thread and a moderator, from Discord's Threads Moderation FAQ:

Discord recommends giving Manage Threads to the people who already have Manage Messages. Threads inherit their other permissions from the parent channel, and members need View Channel there to see any of its threads (permissions reference). One change from this year: since 23 February 2026, Manage Threads no longer skips slowmode; the separate Bypass Slowmode permission does (Slowmode FAQ).

How to Manage Discord Threads Step by Step

On desktop the three dots sit at the top of an open thread. Right-clicking a thread opens a similar menu.

Create a thread

1. Hover over a message, press the three dots and choose Create Thread. This needs Create Public Threads.
2. Add a title if you want one, type your message and send it.

For a private thread, open the Threads menu at the top of the channel or the attachment menu in the chat bar, switch Private Thread on and @mention the people you want in it. You need Create Private Threads, and private threads only exist in normal text channels. Discord's Threads FAQ still ties them to Server Boost Level 2, while the Level 2 perk list in its Server Boosting FAQ does not mention them. A thread holds at most 1,000 members.

Close and reopen a thread

Press the three dots and choose Close Thread. The thread drops out of the thread list and the sidebar for everyone, but the Threads button at the top of the channel still lets you browse all its threads, and channel search includes them. To reopen it, type a message in it or choose Open Thread.

Lock a thread

Locking is a moderator action. Discord's moderation FAQ says a moderator who closes a thread can choose to lock it as well, and in a forum, Close Post locks the post in the same step. A bot can do both in one call, shown further down.

Delete a thread

With Manage Threads, press the three dots and choose Delete Thread. This removes the thread entirely, and Discord's support team cannot bring it back. Deleting the message a thread started from does not delete the thread: the developer documentation says it is then "orphaned" and keeps existing. Every forum post is a thread, so the same permission covers deleting posts.

Edit name, slowmode and Hide After Inactivity

Choose Edit Thread in the same menu. Besides the name, you set Slowmode (5 seconds to 6 hours, off by default, not copied from the parent channel, and only Manage Threads can change it) and Hide After Inactivity.

Auto Archive Durations: Hide After Inactivity

Every thread gets one of four options, which the API stores in minutes (channel reference):

Three details from Discord's threads documentation explain most "why did my thread disappear" questions:

• Activity means a new message, reopening the thread or changing its timer. Reactions are not on that list.
• The timer can run short. Each server has a limit on active threads. As a server gets close to it, Discord lowers the timer, and in very busy channels a thread set to 1 week can close earlier. Once the limit is reached, no new threads can be started or reopened.
• Each channel has a default. Text, announcement and forum channels carry a default_auto_archive_duration that the app pre-selects for new threads. In a forum, the Hide After Inactivity setting plays this role; on a text channel a bot can set it with channel.setDefaultAutoArchiveDuration(ThreadAutoArchiveDuration.OneDay) in discord.js.

How to Archive a Forum Post on Discord

Forum posts are threads with a title and tags, so the same rules apply under forum names (Forum Channels FAQ):

1. Close one post: right-click the post and choose Close Post. It leaves the new posts list, and Discord's FAQ says the post is also locked so only moderators can reopen it.
2. Close posts automatically: in the forum's settings, set Hide After Inactivity to 1 hour, 24 hours, 3 days (the default) or 1 week. Quiet posts move to Older Posts, and unless a post is locked, anyone can reopen it.
3. Mind the pin: a forum holds one pinned post, and it never auto-archives. Closing it removes the pin, according to the developer documentation.
4. Mark it solved: add a moderated tag such as resolved. Only members with Manage Threads can add or remove one.

Our forum channels guide covers tags, layout and post guidelines.

Discord Thread Management Bot: Auto-Archive Example

A bot helps when you want a rule the app cannot express: a thread for every question in #support, a /solved command that locks and closes in one step (also for the member who asked, who normally cannot lock), or closing threads after 6 quiet hours.

No code: YAGPDB custom commands

YAGPDB's custom command functions include createThread (with an auto archive duration of 60, 1440, 4320 or 10080), closeThread, lockThread, openThread, editThread and deleteThread, plus createForumPost and pinForumPost. Its documentation notes that you cannot lock a closed thread but you can close a locked one, so lock first.

Your own bot in discord.js

The bot below was written against discord.js 14.28.0, the latest version on npm on 3 November 2026. It opens a thread for every message in one support channel, adds /solved, and every 30 minutes closes threads in that channel that have had no message for 6 hours.

// bot.js for discord.js 14.28.0 and Node.js 18 or newer
const {
  Client, Events, GatewayIntentBits, MessageFlags, PermissionFlagsBits,
  SlashCommandBuilder, SnowflakeUtil, ThreadAutoArchiveDuration,
} = require('discord.js');

const SUPPORT_CHANNEL_ID = '123456789012345678'; // your #support text channel
const IDLE_HOURS = 6;                              // close threads after 6 quiet hours

const client = new Client({
  intents: [GatewayIntentBits.Guilds, GatewayIntentBits.GuildMessages],
});

// 1. Every new message in #support gets its own thread
client.on(Events.MessageCreate, async (message) => {
  if (message.author.bot || message.channelId !== SUPPORT_CHANNEL_ID || message.hasThread) return;
  await message.startThread({
    name: `Support: ${message.author.username}`,
    autoArchiveDuration: ThreadAutoArchiveDuration.OneDay,
    reason: 'Support request',
  }).catch(console.error);
});

// 2. /solved locks and closes the thread it is used in
const solved = new SlashCommandBuilder()
  .setName('solved')
  .setDescription('Lock and close this support thread');

client.on(Events.InteractionCreate, async (interaction) => {
  if (!interaction.isChatInputCommand() || interaction.commandName !== 'solved') return;
  const thread = interaction.channel;
  if (!thread?.isThread()) {
    return interaction.reply({ content: 'Use this inside a thread.', flags: MessageFlags.Ephemeral });
  }
  // The bot owns threads it opened, so also accept the author of the first message
  const starter = await thread.fetchStarterMessage().catch(() => null);
  const isStarter = thread.ownerId === interaction.user.id || starter?.author.id === interaction.user.id;
  const isMod = interaction.memberPermissions?.has(PermissionFlagsBits.ManageThreads);
  if (!isStarter && !isMod) {
    return interaction.reply({ content: 'Only the thread starter or a moderator can do this.', flags: MessageFlags.Ephemeral });
  }
  try {
    await interaction.reply('Marked as solved. This thread is now locked and closed.');
    await thread.edit({ locked: true, archived: true, reason: `Solved by ${interaction.user.username}` });
  } catch (error) {
    console.error(error);
  }
});

// 3. Every 30 minutes, close #support threads without a message for IDLE_HOURS
async function sweep() {
  const channel = await client.channels.fetch(SUPPORT_CHANNEL_ID);
  const { threads } = await channel.threads.fetchActive();
  const cutoff = Date.now() - IDLE_HOURS * 60 * 60 * 1000;
  for (const thread of threads.values()) {
    const lastActivity = SnowflakeUtil.timestampFrom(thread.lastMessageId ?? thread.id);
    if (lastActivity < cutoff) {
      await thread.setArchived(true, `No messages for ${IDLE_HOURS} hours`);
    }
  }
}

client.once(Events.ClientReady, async (c) => {
  await c.application.commands.set([solved]);
  await sweep().catch(console.error);
  setInterval(() => sweep().catch(console.error), 30 * 60 * 1000);
  console.log(`Logged in as ${c.user.tag}`);
});

client.login(process.env.DISCORD_TOKEN);

To run it:

1. Create an application and bot in the Discord Developer Portal and invite it with the bot and applications.commands scopes.
2. On the support channel, give the bot View Channel, Create Public Threads, Read Message History and Manage Threads. Manage Threads lets it lock threads and close threads it did not start.
3. Run npm install discord.js, put your channel ID in SUPPORT_CHANNEL_ID and start it with DISCORD_TOKEN=your-token node bot.js.

Notes on the code:

• It only needs the Guilds and Guild Messages intents. It never reads message text, so the privileged Message Content intent stays off.
• /solved sends locked and archived in one edit, because Discord's API only accepts changes to a thread that is open or reopened in the same request.
• commands.set() replaces all global commands of your app, so add your other commands to that array.
• The last message time comes from the message ID, which contains a timestamp, so the sweep never has to fetch messages.

In discord.py 2.7.1 the same two calls look like this:

thread = await message.create_thread(name=f"Support: {message.author.name}", auto_archive_duration=1440)
await thread.edit(locked=True, archived=True, reason="Solved")

Errors you may hit, from Discord's JSON error codes:

The sweep only runs while the bot is online, so a laptop that sleeps at night misses it. Our Discord bot hosting runs Node.js and Python bots with no sleep mode, and the paid plans restart a bot automatically after a crash.

Habits That Keep Threads Tidy

• Support: one thread per question, a 24 hour timer, and lock plus close when it is solved.
• Announcements: deny Send Messages but allow Send Messages in Threads, so members discuss under each post without posting in the channel. Discord's moderation FAQ suggests this setup.
• Channels without threads: new servers give @everyone Create Public Threads and Create Private Threads. Turn both off where you do not want threads.

FAQ

How do I delete threads on Discord? Open the thread, press the three dots and choose Delete Thread. It needs Manage Threads and cannot be undone. Without that permission, close the thread or ask a moderator.

How do I archive a forum post on Discord? Right-click the post and choose Close Post. To do it automatically, set Hide After Inactivity in the forum's settings, and quiet posts move to Older Posts.

Do archived Discord threads get deleted? No. A closed thread stays searchable and reopens when someone posts in it, unless it is locked. Only Delete Thread removes it.

Can the person who started a thread close or delete it? They can rename it, close it and change its timer. Locking, slowmode and deleting take Manage Threads, and a thread a moderator closed and locked only opens again for moderators.

What is a good Discord thread management bot? For no-code rules, YAGPDB's custom commands can close, lock, edit and delete threads. For your own rules, a short discord.js bot like the one above works, as long as it has Manage Threads and stays online.

Sources

All opened on 3 November 2026:

• Discord: Threads FAQ
• Discord: Threads Moderation FAQ
• Discord: Forum Channels FAQ
• Discord: Slowmode FAQ
• Discord: Server Boosting FAQ
• Discord Developer Documentation: Threads, Channel resource, Permissions, Opcodes and status codes
• discord.js 14.28.0: ThreadChannel documentation
• discord.py: API reference (Thread.edit, Message.create_thread)
• YAGPDB: Template functions

Related: Discord forum channels setup, Discord ticket bot guide, Discord bot hosting guide