How Discord Estimates Age Without Collecting Your Identity
Discord
September 22, 2026
Document Version
Summary
We built an age estimation model that predicts whether user accounts likely belong to an adult (18+) or teen (13-17) age group so we can apply certain settings and protections.
Our model looks at patterns of account behavior on Discord. It does not read, scan, or analyze the content of users’ messages or voice calls. For example, the way a typical 15-year-old uses Discord (including how many communities they’re a part of and how they interact with others) looks different in aggregate from how a typical 30-year-old uses Discord. Our model has learned these patterns to predict whether a given account likely belongs to an adult or a teen.
The model automatically places users into an age group, so the vast majority of users won’t need to confirm their age. Confirming age manually (i.e. through a selfie, credit card check, or ID scan) is only needed in a few cases. For instance, when someone wants to access age-restricted content, spaces, or settings, and the model can’t confidently place them into an age group (including in regions where the model isn’t deployed yet); or for brand new accounts that we don’t know enough about yet. We designed the model to be highly accurate, but if it gets your age group wrong, we work to make it easy to confirm your age group in other ways.
Background
In February 2026, we promised a technical post explaining how Discord estimates whether someone is an adult without collecting anyone's identity. This post explains how the underlying machine learning (ML) model works to do just that.
The goal is to give both teens and adults an experience appropriate for their age, with as little friction and as much privacy as possible. The ML model we built estimates age from details like how long an account has existed and the kinds of communities it belongs to. No single server determines your age group, and we don’t read your messages (in servers or in DMs) to decide which group you’re in. When the model identifies a user as an adult, they are automatically placed in the adult age group and will not be asked to confirm their age.
Behavioral age estimation with ML is standard practice across the industry, and many large tech and social media companies deploy it as part of their age assurance and safety initiatives.
The ML Model
The model sorts accounts into two groups: teen (13 to 17) and adult (18 or older). Discord requires all users to be at least 13 to use our platform. From here on, "teen" and "adult" refer to these specific definitions.
Model Architecture
We use XGBoost [1] (eXtreme Gradient Boosting), a tree-based ensemble method that builds a series of decision trees where each new tree corrects the errors made by the ones before it. It fits our use case well by:
Handling a mix of tabular features and high-dimensional embeddings in the same model.
Capturing non-linear interactions between features.
Producing feature-importance rankings, which support ongoing model auditing.
Tolerating skewed label distributions (few samples in the minority class) and missing data.
Features the model uses to make predictions
The model uses a combination of structured tabular features and high-dimensional graph embeddings. In simpler terms, this means it learns from both straightforward, spreadsheet-style data and richer information about how different entities relate to one another, condensed into a numerical format the model can process. We selected features to capture organic user behavior while intentionally excluding signals that could introduce demographic bias or leave the system vulnerable to manipulation.
The features are organized into several groups:
User Embeddings: A compact numerical representation of how an account fits into Discord's social graph: which communities it belongs to, which games it plays, and the broad structure of who it interacts with. We generate these using a general-purpose technique called Discord Entity-Relationship Embeddings (DERE) [2]. These embeddings are built purely from the structure of an account's connections. They do not use usernames, profile content, message content, or any other user-generated content of any kind. This is the single most predictive feature in the ML model, and you can refer to the dedicated section “User Embeddings (DERE)” below explaining how it works in more detail.
Account Metadata: Information about the account itself, such as account tenure, subscription history, and email/phone verification status.
Engagement Metrics: Aggregated activity counts (counts only, never content), such as the number of active days on Discord in the past month, the number of servers owned, and the number of messages sent.
Community Context: Signals about the categories of communities a user participates in, based on the server's name and description. We do not read message content or private information to determine this.
System and Platform Metadata: Device signals, such as operating system, browser type, and hardware platform.
Because the model relies primarily on social graph structure rather than individual attributes, it is highly resistant to manipulation. Shifting an account's position in a social graph requires sustained, organic interaction that is difficult to fabricate or reverse-engineer.
To understand which of these features the model relies on most, we use SHAP (SHapley Additive exPlanations) [3], a standard method for measuring how much each feature contributes to a model's predictions. The chart below shows the relative contribution of each feature group. The most predictive features in the model are user embeddings, and are discussed further in the next section.
Figure 1: ML model feature importance, grouped by feature category, using SHAP values.
User Embeddings (DERE)
DERE (Discord Entity-Relationship Embeddings) graph embeddings are the model's most predictive features. DERE is trained on the Discord social graph and encodes the relationships between users, servers, and gaming titles into a compact numerical representation.
Figure 2 below shows a simplified example with ten users (numbered circles), two servers, and three gaming titles. Lines connect users to each other when they are friends, and connect users to the servers they belong to and the games they play. This graph structure is then encoded into a numerical embedding for each user. For this simplified example, the embedding is 2-dimensional (e.g. [0.3259, -0.15232]), but in production our DERE embeddings are 32-dimensional. The power of these numerical embeddings is that they capture the social graph structure: users are placed close to each other if they have strong connections, and far away if they don’t. This behavior forms user communities that are clustered together in the embeddings space.
Figure 2: A simplified example showing the graph representation of relationships between users (numbered circles), servers, and gaming titles. This graph structure gets converted into numerical embeddings for users, shown as 2-dimensional values on the right. Users that have strong connections in the graph are given values close to each other. In production, DERE embeddings are 32-dimensional representations of the entire Discord relationship graph.
DERE is highly predictive of age because users of similar ages tend to form organic social clusters. Teens interact with other teens, join similar communities, and play similar games. Adults do the same. DERE captures this structure without ever being trained on age data. It reflects the shape of an account's connections, not the identities or content within them. To visualize this structure, we used UMAP (Uniform Manifold Approximation and Projection) to project a sample of accounts into two dimensions, shown in Figure 3. The result reveals a fairly clear age structure, which is what the model learns to read. It infers a likely age group from where the account sits in this social graph structure.
Figure 3: For illustration only. This image is a stylized representation of a possible DERE embedding space, not a representation of Discord's actual user population.
Training Data
Over the course of 2025 and 2026, Discord implemented age assurance technology in certain regions around the world in response to new legal obligations. Each rollout generated reliable age data from users who verified their age.
Users confirmed their age through one of two methods: Facial Age Estimation (FAE) or a government ID upload ("ID scan") paired with a matching selfie. The data from users provided as part of the age assurance process was only used to determine their age group, and was not received by Discord or used to train our models. Only the age group data itself (teen or adult) was used for model training and evaluation. As a condition of working with us, we require every age assurance vendor to only store what users submit for as long as it takes to confirm their age, and to permanently delete it immediately after.
Data Privacy & Minimization
The model was designed with privacy as a core constraint. Several categories of data are intentionally excluded from being used in the ML model:
No message content or profile data. The model never uses messages, uploaded media, usernames, or profile bios. It uses some aggregate counts, such as how many messages an account has sent, but never what those messages say. Excluding content protects privacy and helps prevent manipulation, since users could otherwise try to influence the model’s estimate by deliberately using certain keywords.
No sensitive or identity data. The model does not use data from facial scans or government IDs, and only uses the resulting user’s age group returned by the age assurance process as a training label. The model operates entirely on behavioral signals and account metadata associated with a user's account.
No demographic attributes. The model does not use race, gender, ethnicity, or any protected demographic attribute as a model feature.
The model's inputs are limited to aggregate behavioral patterns and account-level metadata. It does not require users to submit any additional personal data beyond what is already associated with their Discord account.
How a score becomes an age group
The model outputs a probability that an account belongs to an adult, between 0 and 1. We convert that probability into a decision using two confidence thresholds. Above the upper threshold, the model has high confidence that the account belongs to an adult and classifies it as an adult. Below the lower threshold, it is confident the account belongs to a teen. Between the two thresholds is an uncertain region, where the model does not have enough confidence to classify either way, and accounts are left unclassified.
Unclassified accounts will also receive additional protections, and those users can confirm their age directly if they’d like to access age-restricted content, spaces, or settings (visit our help page for more information about the different age assurance methods and how they work). The thresholds we’ve set mean some accounts won’t be placed in an age group when the model isn’t confident enough. Because adults make up most of Discord’s users, most of those unclassified accounts will likely belong to adults. We think that’s the right tradeoff: setting a high bar for confidence helps keep our classifications accurate, and when the model can’t reliably determine an account’s age group, we won’t guess. Users incorrectly classified as teens are also able to unlock age-restricted experiences by confirming their age using one of our accepted methods.
Classifications are also stable over time. An account's daily score naturally fluctuates, so instead of acting on any single day, we aggregate scores over a longer window before classifying. This ensures a classification reflects sustained behavior that cannot be changed by a single day.
Performance and Monitoring
The model's performance meets or exceeds the efficacy of methods that are widely used in regions with active age assurance laws, as measured against a held-out evaluation set. In practice, it clears the vast majority of adults on the platform without needing any additional verification.
We re-measure model performance on a regular schedule against recently confirmed age data, and when performance drifts from where we set it, we recalibrate or retrain. When the model is not confident about an account, it does not guess: that account is left unclassified, and if a user wants to access age restricted content, they will be able to pick from a range of age assurance options to confirm their age instead. As we accumulate more confirmed age signals over time, we will continue to improve the model's accuracy.
Conclusion
For most users, none of this will be visible. They will keep using Discord as they always have, while the model works in the background.
This is the first version of a system we expect to keep improving over time. As it becomes more accurate, fewer people will need to confirm their age, and we’ll continue evaluating its performance against the age assurance methods it’s designed to reduce the need for.
References
[1] Chen, T. and Guestrin, C. XGBoost: A Scalable Tree Boosting System (2016). Proceedings of the 22nd ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, 785-794. https://arxiv.org/abs/1603.02754
