Discord Member Scraper

Discord Member Scraper is an Apify Actor for extracting one record per Discord server member from a server where your bot is already installed and has the Server Members Intent enabled. It accepts a Discord bot token and a server ID, then returns member-level fields such as user ID, username, global display name, server display name, nickname, bot status, role IDs, role names when enabled, join date, Nitro boost timestamp, moderation status, and the source guild ID. The result is a structured dataset you can use in Apify, through Apify MCP, or from the Apify API.

Best fit and connected workflows

This Actor fits workflows that start with a known Discord server ID and a valid public bot token. It is a strong routing choice when the next step needs member roster data from a server you manage, such as:

• roster exports for a community or workspace
• role-based member review
• moderator and screening status audits
• boost tracking with member join timing
• downstream enrichment or analysis in other Apify Actors or external systems

The output is already normalized to one record per member, which makes it easy to pass into dataset processing, filtering, or aggregation steps.

Discord Member Scraper is designed as a focused workflow.

Opening contract

Input: a Discord bot token and a server (guild) ID, plus optional filters for maximum members, role-name resolution, bot exclusion, and role-based filtering.

One record means one Discord member from the target guild.

Valuable fields include userId, username, displayName, roleNames, joinedAt, premiumSince, isPending, isTimedOut, and guildId.

Outcome: a dataset of member records ready for review, export, or further workflow processing.

Practical scenario

Maya manages a Discord community and wants a roster of members in the server she moderates. She starts with a bot token, the server ID, and a role filter for Moderator and Verified. The Actor returns records with username, displayName, roleNames, joinedAt, and isTimedOut. Maya uses roleNames and joinedAt to review which members hold important roles and how recently they joined, then exports the dataset for a moderation report.

Input fields

Field	Type	Required	Description
botToken	string	yes	Discord bot token from the Developer Portal. Stored encrypted and never logged.
guildId	string	yes	Numeric Discord server ID to scrape.
maxMembers	integer	no	Maximum number of members to scrape and bill for. Default: 1000.
includeRoleNames	boolean	no	Resolves role IDs to human-readable role names. Default: true.
excludeBots	boolean	no	Skips bot/application accounts. Default: false.
roleFilter	array of strings	no	Optional list of role names or role IDs. Matching is case-insensitive.

Focused input example

{
  "botToken": "YOUR_DISCORD_BOT_TOKEN",
  "guildId": "974519864045756446",
  "maxMembers": 250,
  "includeRoleNames": true,
  "excludeBots": true,
  "roleFilter": ["Moderator", "Verified"]
}

Output fields

Field	Type	Description
userId	string	Discord user snowflake ID.
username	string	Discord username (handle).
globalName	string	Account-wide display name.
displayName	string	Server nickname, else global name, else username.
nickname	string	Per-server nickname if set.
isBot	boolean	True for bot/application accounts.
avatarUrl	string	CDN URL of the member's avatar.
roleIds	array of strings	Role snowflake IDs held by the member.
roleNames	array of strings	Human-readable role names when resolution is enabled.
joinedAt	string	ISO-8601 timestamp the member joined the server.
premiumSince	string	ISO-8601 timestamp the member started Nitro-boosting, if any.
isPending	boolean	True if the member has not passed membership screening.
isTimedOut	boolean	True if the member is currently timed out.
communicationDisabledUntil	string	ISO-8601 timestamp the timeout expires, if any.
guildId	string	The server this record came from.

Illustrative output record

{
  "userId": "100000000000000001",
  "username": "jane_doe",
  "globalName": "Jane",
  "displayName": "Jane (mod)",
  "nickname": "Jane (mod)",
  "isBot": false,
  "avatarUrl": "https://cdn.discordapp.com/avatars/100000000000000001/abc.png?size=256",
  "roleIds": ["200000000000000001"],
  "roleNames": ["Moderator"],
  "joinedAt": "2023-04-01T12:00:00.000000+00:00",
  "premiumSince": null,
  "isPending": false,
  "isTimedOut": false,
  "communicationDisabledUntil": null,
  "guildId": "974519864045756446"
}

How it works

The Actor authenticates with your bot token, reads the target guild, optionally fetches the guild role list once to resolve role names, then paginates the public Discord member endpoint until it reaches the server member set or the maxMembers cap. The live contract also shows bot/account filtering, role-based filtering, and dataset output in Apify format.

Pricing

Discord Member Scraper uses Pay per event pricing plus Apify platform usage. The pricing model is based on a run start event and a per-member event for each returned member. For the current live pricing details, please open the Pricing tab in the Apify console.

As an example, a run that returns one hundred members is billed for one actor start event plus one hundred member events, alongside normal Apify platform usage for the run and dataset storage.

Use with AI agents (MCP)

This Actor is usable through Apify MCP, where the tool performs a Discord member-scraping run and returns structured dataset output for agent workflows. The exact Actor identity is khadinakbar/discord-member-scraper.

Scrape the members of Discord server 974519864045756446 using the bot token I provide. Return the dataset with username, displayName, roleNames, joinedAt, premiumSince, isPending, isTimedOut, and guildId, and keep the result scoped to the target guild.

Output interpretation: each dataset item is one Discord member record. roleNames is populated when role-name resolution is enabled. premiumSince indicates Nitro boosting when present. isPending and isTimedOut reflect current member status values. guildId ties every record back to the source server.

Provenance: the records come from the Discord public Bot API through this Apify Actor. Scope is limited to the server identified by guildId and to the members returned by your selected filters. Pagination continues through the member list until the server is covered or maxMembers is reached. Billing follows the live pay-per-event contract, with one start event and one event per returned member.

Apify API example

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({
    token: process.env.APIFY_TOKEN,
});

const run = await client.actor('khadinakbar/discord-member-scraper').call({
    botToken: process.env.DISCORD_BOT_TOKEN,
    guildId: '974519864045756446',
    maxMembers: 250,
    includeRoleNames: true,
    excludeBots: true,
});

const datasetId = run.defaultDatasetId;
const { items } = await client.dataset(datasetId).listItems({ clean: true, format: 'json' });

console.log(items);

Best results and outcome guidance

Set guildId to the numeric server ID, since the Actor reads Discord members from a single guild per run. Use includeRoleNames: true when you want readable role names in the dataset, and set excludeBots: true when your workflow focuses on human members. roleFilter is useful when the next step only needs specific roles, and maxMembers gives you a clear cap for the run.

If you plan to process the output with an AI agent, keep the fields focused on the downstream task. For example, moderation workflows often start with displayName, roleNames, and isTimedOut, while community analytics may rely more on joinedAt and premiumSince.

Continue the workflow

• Then use Discord Message Scraper to extend Discord Member Scraper research with a complementary content contract.
• Then use Discord Server Scraper — Messages, Members & Channels to extend Discord Member Scraper research with a complementary content contract.

Design note

I found that the dataset contract surfaces both roleIds and roleNames, and the overview table highlights username, displayName, isBot, joinedAt, premiumSince, and guildId. That made it clear the Actor is designed for member-level analysis with optional human-readable role resolution.

FAQ

When should I use this Actor?

Use it when you already know the server ID and have an public Discord bot installed in that server. It is a good fit for member exports, role reviews, moderation audits, and boost tracking.

What input is required for a run?

A Discord bot token and a guild ID are required. The other fields refine the scope and shape of the returned dataset.

Can this Actor resolve role names?

Yes. Set includeRoleNames to true to fetch the guild role list once and map role IDs to readable role names in roleNames.

How does bot exclusion work?

Set excludeBots to true when you want the returned dataset to focus on human members and skip bot/application accounts.

What does role filtering change?

roleFilter limits the result set to members that hold at least one matching role name or role ID. This is useful for targeted member exports and role-specific analysis.

How can I read the output in code?

Use the Apify API or client library to read the default dataset after the execution completes. The output schema points to the dataset items endpoint for cleaned JSON.

Responsible use

Use this Actor for servers where your bot is installed and where your Discord setup supports the Server Members Intent. Handle member data with care, especially when exporting role, join, or moderation status information. Keep your workflows aligned with Discord's public developer terms and your own data-handling requirements.