Start here: what the Message Content intent does
The Message Content intent is a privileged Gateway intent (MESSAGE_CONTENT, 1 << 15) that lets your Discord bot read the content, embeds, attachments, components and poll fields of messages. Without it, your bot still receives message events, but those fields arrive empty - so prefix commands like !help silently never match. To use it, toggle Message Content Intent on the Bot page of the Developer Portal and request it in your code, then restart the bot.
Last verified: November 2026 against Discord's Gateway documentation, the Privileged Intent Review guide and the developer change log.
Two facts trip up most developers. First, it is not tied to any event: per Discord's Gateway docs, it "isn't directly associated with any Gateway events. Instead, access to MESSAGE_CONTENT permits your app to receive message content data across the APIs." That includes REST responses, not just the Gateway. Second, missing it does not produce an error. Your bot connects, shows online, receives MESSAGE_CREATE, and reads an empty string.
| Situation | What you observe |
|---|---|
| Intent off in portal, not requested in code | Bot online; message.content is "" in servers |
| Intent requested in code, off in portal | Connection closed with 4014 Disallowed intent(s) |
| Intent on in portal, not requested in code | Bot online; content still empty |
| On in portal and requested in code | Content populated |
What changed in 2026: 10,000 users replaces the 100-server rule
Most guides still say you can toggle privileged intents freely until your bot reaches 100 servers. That stopped being true on June 10, 2026. Discord's change log and the Privileged Intent Review guide describe the new rules:
- The review threshold is users, not servers. If your app is accessible to fewer than 10,000 unique users across all its servers, you can turn privileged intents on and off in the Developer Portal with no application. Once it passes 10,000 users, you must apply for access. Discord's own example: a bot in 50 large servers can hit the threshold while a bot in 200 small servers may not.
- A 90-day window. When an app crosses the threshold with a privileged intent enabled, the owner is notified (system DM and/or email, plus a callout in the portal) and has 90 days to apply. Miss the window and existing access is removed, though you can apply again any time.
- Annual reapplication. Apps already granted access must reapply once a year, again with a 90-day window after the notice.
- Bots keep working during review. An app under review continues to use the intents it requested and can keep joining servers.
- Verification and intent review are now separate processes. The Gateway docs still describe verification as "required for apps in 100+ guilds", but it no longer doubles as your intent review.
Practical meaning: a small bot does not need permission from anyone, but you should still build with the minimum set of intents, because growth later forces you to justify each one in writing.
When you get content without the intent
The intent is not needed in several situations, which is why a bot can "work in DMs but not in the server" or "respond when pinged but ignore everything else". Discord's docs list these exceptions:
- Messages your app sends.
- Direct messages sent to your app.
- Messages that @mention your app.
- The target message of a message context menu command (right-click a message, Apps, your command).
- Replies to your app's messages made with Discord's reply feature with "ping on reply" enabled. Discord's You Might Not Need a Privileged Intent guide notes this does not apply to replies to slash command responses.
If your feature can be designed around those - mention the bot, DM the bot, or use a context menu - you do not need the intent at all. That is not a workaround; it is what Discord explicitly recommends: "If your app's functionality can be built to work with this access, you should not request the Message Content intent."
Note what the intent does not gate: it does not stop you receiving MESSAGE_CREATE (that is GUILD_MESSAGES and DIRECT_MESSAGES), and it does not affect message IDs, authors, timestamps or channel IDs. A bot that only needs to know that someone posted - activity counters, XP systems based on message count - works without it.
Enabling it in the Developer Portal
- Open
discord.com/developers/applicationsand select your app. - Go to the Bot page in the left sidebar.
- Scroll to Privileged Gateway Intents.
- Toggle Message Content Intent on and save the change.
- Restart the bot. Discord's review guide is explicit: intent changes only take effect on a new Gateway connection, so a running bot will not pick them up until it reconnects.
If the toggle is locked, your app is over the 10,000-user threshold and needs approved access; apply from the same page. The other two privileged intents live in the same section: Presence Intent (GUILD_PRESENCES) and Server Members Intent (GUILD_MEMBERS). Do not enable them "just in case" - each one is something you will have to justify if the bot grows.
Requesting it in code: discord.js, discord.py and raw Gateway
Since Gateway API v8, every intent you want must be listed when you identify. The portal toggle grants permission; your code has to ask for it.
discord.js (v14)
import { Client, GatewayIntentBits, Events } from "discord.js";
const client = new Client({
intents: [
GatewayIntentBits.Guilds,
GatewayIntentBits.GuildMessages, // receive MESSAGE_CREATE in servers
GatewayIntentBits.MessageContent, // privileged: populate message.content
],
});
client.on(Events.MessageCreate, (msg) => {
if (msg.author.bot) return;
if (msg.content === "!ping") msg.reply("pong");
});
client.login(process.env.DISCORD_TOKEN);
MessageContent without GuildMessages is a common half-fix: you are allowed to read content, but you never receive the server messages that would contain it. Add GatewayIntentBits.DirectMessages (and the Partials.Channel partial) if you also handle DMs.
discord.py (2.x)
import os, discord
from discord.ext import commands
intents = discord.Intents.default()
intents.message_content = True # privileged
bot = commands.Bot(command_prefix="!", intents=intents)
@bot.command()
async def ping(ctx):
await ctx.send("pong")
bot.run(os.environ["DISCORD_TOKEN"])
Intents.default() deliberately leaves out the privileged intents, so prefix commands in commands.Bot do nothing in servers until you set message_content = True.
Raw Gateway identify
If you speak to the Gateway directly, add the bit to your intents integer. GUILDS (1 << 0) + GUILD_MESSAGES (1 << 9) + MESSAGE_CONTENT (1 << 15) = 1 + 512 + 32768 = 33281:
{
"op": 2,
"d": {
"token": "YOUR_BOT_TOKEN",
"intents": 33281,
"properties": { "os": "linux", "browser": "my_bot", "device": "my_bot" }
}
}
A wrongly calculated value that includes undefined bits closes the connection with 4013 Invalid intent(s), which is different from 4014.
Requesting it in Go, Java, C# and Rust
Every major library starts from a non-privileged default and expects you to add Message Content explicitly. That is the safe choice, and it is why "I enabled the toggle and nothing changed" is so common. Code that never asks for the intent still gets empty content.
| Library | Default intents | How to add Message Content |
|---|---|---|
| discord.js | None - you must list every intent | GatewayIntentBits.MessageContent |
| discord.py | Intents.default() leaves out privileged intents | intents.message_content = True |
| discordgo | IntentsAllWithoutPrivileged, set in New() | discordgo.IntentMessageContent |
| JDA | createDefault disables GUILD_MEMBERS, GUILD_PRESENCES and MESSAGE_CONTENT | .enableIntents(GatewayIntent.MESSAGE_CONTENT) |
| Discord.Net | GatewayIntents.AllUnprivileged excludes it | GatewayIntents.MessageContent |
| serenity | GatewayIntents::non_privileged() excludes it | GatewayIntents::MESSAGE_CONTENT |
Go (discordgo)
dg, _ := discordgo.New("Bot " + os.Getenv("DISCORD_TOKEN"))
dg.Identify.Intents = discordgo.IntentsGuilds |
discordgo.IntentsGuildMessages |
discordgo.IntentMessageContent // privileged
dg.AddHandler(func(s *discordgo.Session, m *discordgo.MessageCreate) {
if m.Author.Bot {
return
}
if m.Content == "!ping" {
s.ChannelMessageSend(m.ChannelID, "pong")
}
})
dg.Open()Java (JDA)
JDA jda = JDABuilder.createDefault(System.getenv("DISCORD_TOKEN"))
.enableIntents(GatewayIntent.MESSAGE_CONTENT) // privileged
.addEventListeners(new PingListener())
.build();C# (Discord.Net)
var client = new DiscordSocketClient(new DiscordSocketConfig
{
GatewayIntents = GatewayIntents.AllUnprivileged | GatewayIntents.MessageContent
});Rust (serenity)
let intents = GatewayIntents::non_privileged() | GatewayIntents::MESSAGE_CONTENT;
let mut client = Client::builder(&token, intents).event_handler(Handler).await?;Whichever library you use, the portal toggle still has to be on for the same application whose token you load. Our guide to getting a Discord bot token covers the dev-versus-production application split that causes most "wrong app" 4014s.
Every Gateway intent and its bit value
If you build the identify payload yourself, or just want to check what a number in someone's config means, this is the full list from Discord's Gateway documentation. The three privileged intents are marked.
| Intent | Bit | Value | Notable events |
|---|---|---|---|
| GUILDS | 1 << 0 | 1 | GUILD_CREATE, channel, role and thread events |
| GUILD_MEMBERS (privileged) | 1 << 1 | 2 | GUILD_MEMBER_ADD / UPDATE / REMOVE |
| GUILD_MODERATION | 1 << 2 | 4 | Bans, audit log entries |
| GUILD_EXPRESSIONS | 1 << 3 | 8 | Emoji, sticker and soundboard updates |
| GUILD_INTEGRATIONS | 1 << 4 | 16 | Integration events |
| GUILD_WEBHOOKS | 1 << 5 | 32 | WEBHOOKS_UPDATE |
| GUILD_INVITES | 1 << 6 | 64 | INVITE_CREATE / DELETE |
| GUILD_VOICE_STATES | 1 << 7 | 128 | VOICE_STATE_UPDATE |
| GUILD_PRESENCES (privileged) | 1 << 8 | 256 | PRESENCE_UPDATE |
| GUILD_MESSAGES | 1 << 9 | 512 | MESSAGE_CREATE / UPDATE / DELETE in servers |
| GUILD_MESSAGE_REACTIONS | 1 << 10 | 1024 | Reaction add / remove |
| GUILD_MESSAGE_TYPING | 1 << 11 | 2048 | TYPING_START |
| DIRECT_MESSAGES | 1 << 12 | 4096 | MESSAGE_CREATE in DMs |
| DIRECT_MESSAGE_REACTIONS | 1 << 13 | 8192 | Reactions in DMs |
| DIRECT_MESSAGE_TYPING | 1 << 14 | 16384 | Typing in DMs |
| MESSAGE_CONTENT (privileged) | 1 << 15 | 32768 | No events of its own - fills content fields |
| GUILD_SCHEDULED_EVENTS | 1 << 16 | 65536 | Scheduled event create / update / delete |
| AUTO_MODERATION_CONFIGURATION | 1 << 20 | 1048576 | AutoMod rule changes |
| AUTO_MODERATION_EXECUTION | 1 << 21 | 2097152 | AUTO_MODERATION_ACTION_EXECUTION |
| GUILD_MESSAGE_POLLS | 1 << 24 | 16777216 | Poll votes in servers |
| DIRECT_MESSAGE_POLLS | 1 << 25 | 33554432 | Poll votes in DMs |
Common combinations
| Bot type | Intents | Value |
|---|---|---|
| Prefix-command bot in servers | GUILDS + GUILD_MESSAGES + MESSAGE_CONTENT | 33281 |
| Same, also answering DMs | + DIRECT_MESSAGES | 37377 |
| Slash-command-only bot | GUILDS | 1 |
| Bot that counts messages but never reads them | GUILDS + GUILD_MESSAGES + DIRECT_MESSAGES | 4609 |
A value with bits Discord does not define closes the connection with 4013. A valid value that includes a privileged bit you have not enabled closes it with 4014. Gateway connections are long-lived WebSockets, so you only find out at identify time, which is another reason to log close codes rather than swallow them.
Close code 4014: Disallowed intent(s)
Discord's close code table defines 4014 as: "You sent a disallowed intent for a Gateway Intent. You may have tried to specify an intent that you have not enabled or are not approved for." It is marked as not reconnectable - retrying the same identify will fail the same way, so libraries stop and raise. What each library prints:
| Library | What you see |
|---|---|
| discord.js / @discordjs/ws | Error: Used disallowed intents |
| discord.py | discord.errors.PrivilegedIntentsRequired: Shard ID None is requesting privileged intents that have not been explicitly enabled in the developer portal... |
| Raw WebSocket | Close frame with code 4014 right after identify |
The fix is always one of three:
- Toggle is off. Turn on the matching intent on the Bot page. Check all three privileged intents, not just Message Content - requesting
GuildMembersorGuildPresenceswithout the toggle triggers the same code. - Wrong application. The token in your environment belongs to a different app (often a dev copy) than the one you toggled.
- Access removed or not granted. Over the 10,000-user threshold, without approved access, or past a missed 90-day window. Apply in the portal, or remove the intent from your code.
The reverse mismatch - enabled in the portal, not requested in code - never errors. It just leaves content empty, which is why "my bot is online and ignores commands" is the more common report. Our Discord bot not responding guide covers the other causes of a silent bot once intents are ruled out.
The other two privileged intents: Server Members and Presence
Message Content gets the attention, but the review applies to all three privileged intents. Discord's guide You Might Not Need a Privileged Intent lists what each one unlocks and what works without it:
| Intent | What it unlocks | What works without it |
|---|---|---|
Server Members (GUILD_MEMBERS) | Join, update and leave events; the full member list via Request Guild Members or List Guild Members | Get Guild Member by ID, Search Guild Members by name prefix, and the member object included in every interaction payload |
Presence (GUILD_PRESENCES) | PRESENCE_UPDATE: online status, activities and client platform | approximate_presence_count on the guild object, Get User for profiles, and setting your own bot's status |
Two side effects are easy to miss. First, without GUILD_PRESENCES (or in servers over 75,000 members), the members and presences arrays in GUILD_CREATE contain only your bot and users in voice channels. Code that builds a member cache from that event silently ends up with a near-empty cache. Second, requesting a server's entire member list over the Gateway needs GUILD_MEMBERS; a prefix query still works without it but returns at most 100 members.
The most common legitimate need for Server Members is a welcome message: to post something when someone joins, a bot has to receive GUILD_MEMBER_ADD, and only that intent delivers it. Discord's review guide lists "My welcome messages stopped firing" as a standard symptom. If you only need to look up the member who just ran a command, you already have them in the interaction - no intent required. For moderation features, check first whether Discord's built-in AutoMod covers them: AutoMod blocks show up to bots as 200000, and the review guide calls replicating AutoMod "generally not considered a compelling use case for access."
REST responses, and writing an intent application that gets approved
The intent applies to REST too
Developers often assume that if the Gateway hides content, fetching the message over HTTP will reveal it. It will not. Discord's Gateway docs state that privileged intents also affect the HTTP API, and that those HTTP restrictions are "independent of Gateway restrictions, and are unaffected by which intents your app passes in the intents parameter". In other words, for REST the portal toggle (and approval, if you are over the threshold) is what counts. Fetching channel history without access gives you message objects with empty content fields, and some endpoints require the intent outright: the Search Guild Messages endpoint Discord documented in March 2026 needs both the READ_MESSAGE_HISTORY permission and MESSAGE_CONTENT.
If you have to apply
Over 10,000 users, access is a written application. Discord's review guide is direct about what gets denied: requests that do not show the use case requires access (for example, because it could be built with interactions), and submissions that are unclear or incomplete. Its advice, condensed:
- Be specific. "My bot needs message content" is not a justification; describe the feature, what data it reads and why a slash command, context menu or modal cannot replace it.
- Request only what you use. Asking for Presence or Server Members alongside Message Content without a matching feature hurts the submission.
- Explain data handling. Say whether you store message content, for how long and how it is secured - or that you process it in memory and discard it.
- Show it working. Discord suggests including evidence such as screenshots or video of the feature.
- Plan for the annual renewal. Keep the write-up somewhere you can update; you will resubmit it every year.
For moderation bots, Discord adds a pointed check: does the feature go beyond what the AutoMod API already supports? Replicating AutoMod is "generally not considered a compelling use case for access."
The alternative Discord wants you to use: slash commands
Discord's review guide calls text-to-slash migration "the most common reason developers request the Message Content privileged intent" and recommends slash commands as the replacement. They need no privileged intent at all, and they bring things a prefix parser never had:
| Need | Prefix command + Message Content | Interaction-based alternative |
|---|---|---|
| Run a command with arguments | Parse !cmd arg from content | Slash command with typed options (string, integer, user, channel, role, attachment...) |
| Act on a specific message (translate, report, save) | Read every message | Message context menu command - you receive the target message's content |
| Collect free text from a user | Wait for their next message | Modal with text inputs |
| Let users pick from choices | React or type a number | Buttons or select menus |
Slash commands also handle discovery (users see them in the / picker), argument validation and autocomplete. Keep Message Content only when the feature genuinely requires reading free-form conversation - for example AI assistants that join a channel conversation or moderation beyond what AutoMod covers - and write down why, because over 10,000 users that explanation becomes your application.
If you are building a support or FAQ bot and would rather not run Gateway code at all, Conferbot's Discord integration handles the connection side so you can design the conversation instead.
Debug checklist for empty message content
- Log
message.contentlength andmessage.guild. Empty only in servers, but fine in DMs or when mentioned? It is the intent. - Check the Bot page: Message Content Intent toggled on for this application ID.
- Check your client constructor:
MessageContent/message_contentplusGuildMessagesrequested. - Restart the process after any portal change.
- If the connection closes immediately, read the close code: 4014 means a privileged intent mismatch, 4013 a malformed bitfield, 4004 a bad token.
- If content arrives but the bot still cannot answer, it is permissions: see 50013 Missing Permissions and check channel overwrites with the permissions calculator.
Every code mentioned here has its own page in the Discord error code directory, and platform quotas are summarized on the Discord limits page.
Running Discord as a support or sales channel, not just a community server
Support bots are the case where Discord's preferred alternatives fit least. A member with a problem types a sentence into a help channel; they do not type a slash command with typed options. You can design around that - ask members to mention the bot, open a DM, or start from a button - and Discord recommends exactly that where it works. If the bot has to answer free-form questions in a channel without being mentioned, though, that is reading conversation, and it needs Message Content.
Designing a support bot that keeps the intent narrow
- Use DMs and mentions where you can. Both are explicit exceptions, so a bot that answers DMs and @mentions needs no privileged intent at all.
- Use a dedicated help channel if you need the intent, and say so in your application. "Reads messages in #support to answer product questions and hand off to staff" is a specific, reviewable use case.
- Process, don't store. If you only need a message long enough to answer it, say that you process content in memory and discard it - Discord's review guide asks about retention directly.
- Treat content as untrusted input if an AI model reads it. A bot that pastes channel messages into an LLM prompt can be steered by those messages; our guide to prompt injection covers the defenses.
- Plan the handoff. A support bot that cannot answer should pass the member to a person. Our human handoff guide covers when and how.
Discord support bots fit some audiences better than others: education servers running cohorts, creator and media communities, developer communities and nonprofit volunteer hubs. For the community side - roles, onboarding and moderation - see Discord bot community management.
Where Conferbot fits
Conferbot's Discord integration is this kind of bot. It reads what members type and answers with messages and buttons in DMs, replies or threads, so its setup has you turn on Message Content Intent for your application, as described above. Under 10,000 users that is a toggle; above it, you apply with your support use case like any other app. What you skip is the code: Conferbot keeps the Gateway connection and intents in sync, so a toggle mismatch never becomes a 4014 crash loop. Conversations can hand off to live chat, and on Pro and up they can push data out through the integrations hub. It does not register slash commands and is not a moderation bot.
When to stop maintaining the plumbing
Everything in this guide is transport-layer work: which bits to send, which toggles to flip, which library default left content empty, which close code means what, and what to write in an application you will resubmit every year. None of it is your product. Every platform charges its own version of this toll - our guides to Slack bots not responding and Telegram bots not responding exist because the same "online but silent" problem has a different cause on each one.
That is a fair trade for a community bot you enjoy building. It is a worse one when Discord is a support or sales channel, and worse again when it is one of several. Conferbot runs the same flow on Telegram, WhatsApp, Slack and a website widget, and you can try it on the free plan before deciding.
Start free with Conferbot - the free plan includes 600 conversations a month and needs no credit card, so you can have the same flow running on a second channel this afternoon.
If you are debugging today, work the checklist above: empty content in servers but not in DMs is the intent, every time. If the bot still will not post, see the invite link guide for permissions, or 50001 Missing Access for channel visibility. If the bot only needs to post into a channel and never read it, a webhook needs no intent at all.
Was this article helpful?
Build and deploy in 10 minutes. No coding needed.
Discord Message Content Intent FAQ
Everything you need to know about chatbots for discord message content intent.
About the Author
The Conferbot team writes about building, deploying, and improving AI chatbots.
View all articlesRelated Articles
From the reference shelf
Fact-checked reference pages and free tools for the platform this article covers.