Comprehensive collection of Discord, OpenAI, Anthropic, Spotify, YouTube, Twitter, Slack, Imgur, DropBox, Box and various Google API endpoint handlers
Discord is the only completed set of handlers, the rest are still in early development
Choose one of the following options to authenticate:
Option 1: Using Environment Variablese
If you are using OnSocket, use this file to get the valid keys but add them to OnSocket's environment variables on the website itself.
Rename the provided .env.example
file at the root of your project to .env
and fill in any tokens/keys you wish to use.
Option 2: Using Initialization Function
const mapih = require('mapih');
// Minimum requirement if using this method
mapih.initialize({ discord: 'bot_token' });
// All possible properties
mapih.initialize({
discord: 'bot_token',
openai: 'sk-1p7NKtCpA0sG7XLdT3L7EqW9GFefX',
spotify: {
client_id: 'cc4287d9Cm4692a9f681d07d9boqji83',
client_secret: '898Nb8f7b09tMnb2lkj3c55443ddmn0ze',
redirect_uri: 'http:localhost:8001/spotify',
scope: 'user-read-email user-read-private'
},
google: {
api_key: 'AISlkuhyA4q4L9m0c3I09maoOYTN0wuyWdA',
client_id: '2164170085-9r94msc46elo.apps.googleusercontent.com',
client_secret: 'GOSLPM-sPn88Kn6GWk90Nh0uk_MNim7698By4',
redirect_uri: 'http://localhost:8001/youtube'
},
slack: {
user: '6942854604069-6272480346098-6284925009575-6901309',
bot: '6942854604069-6262140883098-Vt6RKehxmTj4Luvvy',
client_id: '6942854604069.624286609478',
client_secret: '4e4998dh94rl846bdsdfegfb0f12',
redirect_uri: 'http:localhost:8001/slack',
user_scope: 'admin users:read.email',
bot_scope: 'users:read.email channels:read'
},
dropbox: {
basic_token: 'N09asdfGlzZzB9P63465efasNWxAvfpk3dQ',
access_token: 'sl.BsobToktTBbsdf235aiihH7j60T_4T',
client_id: '7cxvzmptyug7ymc9',
client_secret: 'easdf8980k6csdf5y7u',
redirect_uri: 'http:localhost:8001/dropbox'
},
box: {
client_id: '3sdfgi8j90fpl8q25809sd0',
client_secret: 'Jsdf6BB4UErgS2chrg4365sdfBXS',
redirect_uri: 'http:localhost:8001/box'
},
});
(async() => {
await mapih.discord.channels.messages.create({
channel_id: '774133713733812275',
content: 'hello'
});
})();
• Applications
◦ getMe
◦ updateMe
◦ appRoleConnectionMeta
◦ updateAppRoleConnectionMeta
◦ commands
‣ retrieve
‣ getAll
‣ create
‣ update
‣ destroy
‣ bulkOverwrite
‣ retrievePermissions
‣ getAllPermissions
‣ updatePermissions
◦ entitlements
‣ getAll
‣ create
‣ destroy
◦ skus
‣ getAll
• Audit Log
◦ retrieve
• Auto Moderation
◦ retrieveRule
◦ getAllRules
◦ createRule
◦ updateRule
◦ destroyRule
• Channels
◦ retrieve
◦ update
◦ destroy
◦ updatePermissions
◦ deletePermissions
◦ getinvites
◦ inviteCreate
◦ typingCreate
◦ followAnnouncementChannel
◦ groupDMadd
◦ groupDMremove
◦ messages
‣ retrieve
‣ getAll
‣ create
‣ update
‣ destroy
‣ bulkDelete
‣ crosspost
‣ pin
‣ unpin
‣ getPinned
◦ threads
‣ forumThreadCreate
‣ createFromMessage
‣ createWithoutMessage
‣ join
‣ leave
‣ addMember
‣ removeMember
‣ retrieveMember
‣ getAllMembers
‣ getAllPublicArchived
‣ getAllPrivateArchived
‣ getAllJoinedPrivateArchived
◦ reactions
‣ create
‣ deleteOwn
‣ deleteUser
‣ deleteAll
‣ deleteAllEmoji
‣ getUsers
• Guilds
◦ create
◦ update
◦ destroy
◦ retrieve
◦ destroy
◦ getPreview
◦ retrieveBan
◦ getAllBans
◦ createBan
◦ destroyBan
◦ getInvites
◦ updateMFAlevel
◦ getPruneCount
◦ beginPrune
◦ getVoiceRegions
◦ getAllIntegrations
◦ destroyIntegration
◦ retrieveWidget
◦ retrieveWidgetImage
◦ retrieveWidgetSettings
◦ updateWidget
◦ retrieveVanityURL
◦ retrieveWelcomeScreen
◦ updateWelcomeScreen
◦ retrieveOnboarding
◦ updateOnboarding
◦ newMemberWelcome
◦ channels
‣ getAll
‣ create
‣ updatePositions
◦ members
‣ retrieve
‣ getAll
‣ search
‣ remove
‣ update
‣ updateCurrent
‣ addRole
‣ removeRole
‣ getPermissionNames
‣ timeout
◦ roles
‣ retrieve
‣ getAll
‣ create
‣ update
‣ destroy
‣ updatePositions
◦ emojis
‣ retrieve
‣ getAll
‣ create
‣ update
‣ destroy
◦ stickers
‣ retrieve
‣ nitroPacks
‣ getAll
‣ retrieveGuild
‣ create
‣ update
‣ destroy
◦ events
‣ retrieve
‣ getAll
‣ getUsers
‣ create
‣ update
‣ destroy
◦ templates
‣ retrieve
‣ getAll
‣ create
‣ createGuild
‣ sync
‣ update
‣ destroy
• Interactions
◦ callback
‣ reply
‣ defer
‣ get_original
‣ update_original
‣ delete_original
‣ component_defer
‣ component_update
‣ autocomplete_reply
‣ modal_reply
‣ upgrade
◦ followup
‣ retrieve
‣ create
‣ update
‣ destroy
• Invites
◦ retrieve
◦ revoke
• OAuth 2
• Stage Instances
◦ retrieve
◦ create
◦ update
◦ destroy
• Users
◦ retrieve
◦ currentUser
◦ myGuilds
◦ currentMember
◦ updateCurrent
◦ connections
◦ appRoleConnection
◦ updateAppRoleConnection
◦ createDM
◦ createGroupDM
◦ leaveGuild
• Webhooks
◦ retrieve
◦ retrieveWithToken
◦ retrieveChannel
◦ retrieveGuild
◦ retrieveMessage
◦ updateMessage
◦ destroyMessage
◦ create
◦ update
◦ updateWithToken
◦ destroy
◦ destroyWithToken
◦ execute
• Objects/Types
◦ Guilds
◦ Users
◦ Channels
◦ Interactions
◦ Roles
◦ Emojis/Stickers
◦ Message Components
◦ Webhooks
◦ Invites
◦ Application
◦ Audit Log
◦ Auto Moderation
• Chat
◦ create
• Images
◦ create
• Speech
◦ create
• Embeddings
◦ create
Docs coming soon
• Users
◦ me
◦ topItems
◦ getProfile
• Search
◦ advanced
◦ artists
◦ songs
◦ albums
• Songs
◦ retrieve
◦ retrieveMany
◦ recommendations
◦ save
◦ unsave
◦ saved
◦ isSaved
◦ analyze
◦ audioFeatures
◦ audioFeaturesMany
• Artists
◦ retrieve
◦ retrieveMany
◦ recommendations
◦ albums
◦ related
◦ follow
◦ unfollow
◦ following
◦ isFollowing
• Albums
◦ retrieve
◦ retrieveMany
◦ songs
◦ new
◦ save
◦ unsave
◦ saved
◦ isSaved
• Playlists
◦ featured
◦ category
◦ create
◦ addSongs
◦ update
◦ updateSongs
◦ removeSongs
◦ retrieveSongs
◦ created
◦ following
◦ isFollowing
◦ follow
◦ unfollow
◦ user
◦ cover
◦ updateCover
• Playback
◦ state
◦ currentSong
◦ devices
◦ togglePlayback
◦ pause
◦ skip
◦ previous
◦ seek
◦ setVolume
◦ toggleShuffle
◦ toggleRepeat
◦ queue
◦ recent
◦ addToQueue
◦ transfer
• Storage
◦ get
◦ getMany
◦ set
◦ setMany
◦ delete
◦ deleteMany
◦ merge
◦ push
◦ export
◦ filter
◦ all
◦ has
◦ entries
◦ keys
◦ values
◦ size
◦ bytes
◦ toJson
◦ clear
◦ equals
◦ history
◦ clearHistory
All functions relating to Discord Guilds (servers)
Field |
Type |
Description |
guild_id |
snowflake |
the id of the guild |
with_counts? |
boolean |
Approcimate member and presence counts |
await mapih.discord.guilds.retrieve({
guild_id: '0000000000'
});
This endpoint can be used only by bots in less than 10 servers.
Field |
Type |
Description |
name |
string |
Name of the guild (2-100 characters) |
icon? |
string/buffer |
Guild icon (url to image or image buffer) |
roles? |
array of Role objects |
Roles to add to the guild |
channels? |
array of PartialChannel objects |
Channels to add to the guild |
verification_level? |
number |
The guild's verification level
|
default_message_notifications? |
number |
Default message notification level
|
explicit_content_filter? |
number |
Explicit content filter level |
afk_channel_id? |
snowflake |
ID for afk channel |
afk_timeout? |
number |
afk timeout in seconds, can be set to: 60, 300, 900, 1800, 3600 |
system_channel_id? |
snowflake |
The id of the channel where guild notices such as welcome messages and boost events are posted |
system_channel_flags? |
number |
System channel flags |
await mapih.discord.guilds.create({
name: "Eric's Server",
icon: 'https://imgurl.png', // or buffer
default_message_notifications: 1, // ONLY_MENTIONS
verification_level: 0, // NONE
explicit_content_filter: 0, // DISABLED
roles: [{
name: 'Administrator',
permissions: 1 << 3,
hoist: 'true',
mentionable: 'false'
}],
channels: [
{
name: 'my-category',
type: 4, // GUILD_CATEGORY
id: 1
},
{
name: 'bot-testing',
type: 0, // GUILD_TEXT
id: 2,
parent_id: 1 // 'my-category'
}
]
});
Field |
Type |
Description |
name |
string |
Name of the guild (2-100 characters) |
description |
string |
|
owner_id |
snowflake |
User id to transfer server ownership to |
icon |
url/buffer |
|
splash |
url/buffer |
|
discovery_splash |
url/buffer |
|
banner |
url/buffer |
|
verification_level |
number |
The guild's verification level
|
default_message_notifications |
number |
Default message notification level
|
explicit_content_filter |
number |
Explicit content filter level |
afk_channel_id |
snowflake |
id for afk channel |
afk_timeout |
number |
afk timeout in seconds, can be set to: 60, 300, 900, 1800, 3600 |
system_channel_id |
snowflake |
The id of the channel where guild notices such as welcome messages and boost events are posted |
system_channel_flags |
number |
System channel flags |
rules_channel_id |
snowflake |
|
system_updates_channel_id |
snowflake |
|
premium_progress_bar_enabled |
number |
|
await mapih.discord.guilds.update({
name: "Eric's New Server",
// ...
});
Field |
Type |
Description |
guild_id |
snowflake |
the id of the guild |
await mapih.discord.guilds.destroy({
guild_id: '0000000000'
});
• If the user is not in the guild, then the guild must be lurkable.
Field |
Type |
Description |
guild_id |
snowflake |
the id of the guild |
await mapih.discord.guilds.getPreview({
guild_id: '0000000000'
});
• Returns a ban object for the given user or a 404 not found if the ban cannot be found.
• Requires the BAN_MEMBERS
permission.
Field |
Type |
Description |
guild_id |
snowflake |
the id of the guild |
user_id |
snowflake |
The ID of the user the ban was created for |
await mapih.discord.guilds.retrieveBan({
guild_id: '0000000000',
user_id: '0000000000'
});
Field |
Type |
Description |
guild_id |
snowflake |
the id of the guild |
limit? |
number |
Number of users to return (up to maximum 1000) (default 1000) |
before? |
snowflake |
Consider only users before given user ID |
after? |
snowflake |
Consider only users after given user ID |
await mapih.discord.guilds.getAllBans({
guild_id: '0000000000',
limit: 50,
after: '0000000000'
});
• Requires the BAN_MEMBERS
permission.
Field |
Type |
Description |
guild_id |
snowflake |
the id of the guild |
user_id |
snowflake |
User ID of the user to ban |
delete_message_seconds? |
snowflake |
Number of seconds to delete the banned user's messages for, between 0 and 604800 (7 days). |
reason? |
string |
Reason for the ban |
await mapih.discord.guilds.createBan({
guild_id: '0000000000',
user_id: '0000000000',
delete_message_seconds: 604800,
reason: 'not cool enough'
});
• Requires the BAN_MEMBERS
permission.
Field |
Type |
Description |
guild_id |
snowflake |
the id of the guild |
user_id |
snowflake |
User ID of the user to unban |
reason? |
string |
Reason |
await mapih.discord.guilds.destroyBan({
guild_id: '0000000000',
user_id: '0000000000',
reason: 'ok I guess you\'re alright'
});
• Requires guild ownership.
Field |
Type |
Description |
guild_id |
snowflake |
the id of the guild |
level |
number |
MFA level |
await mapih.discord.guilds.updateMFAlevel({
guild_id: '0000000000',
level: 0
});
• By default, prune will not remove users with roles.
• You can optionally include specific roles in your prune by providing the include_roles
parameter.
• Any inactive user that has a subset of the provided role(s) will be counted in the prune and users with additional roles will not.
Field |
Type |
Description |
guild_id |
snowflake |
the id of the guild |
days |
number |
Number of days to count prune for (1-30) (Default 7) |
include_roles? |
string[] |
An array of role IDs to include |
await mapih.discord.guilds.getPruneCount({
guild_id: '0000000000',
days: 3,
include_roles: [
'0000000000'
]
});
• For large guilds it's recommended to set the compute_prune_count
option to false
, forcing pruned
to null
.
• By default, prune will not remove users with roles.
• You can optionally include specific roles in your prune by providing the include_roles
parameter.
• Any inactive user that has a subset of the provided role(s) will be counted in the prune and users with additional roles will not.
Field |
Type |
Description |
guild_id |
snowflake |
the id of the guild |
days |
number |
Number of days to count prune for (1-30) (default 7) |
compute_prune_count |
boolean |
Whether pruned is returned, discouraged for large guilds (default true) |
include_roles? |
snowflake[] |
An array of role IDs to include |
reason? |
string |
Reason |
await mapih.discord.guilds.beginPrune({
guild_id: '0000000000',
days: 3,
compute_prune_count: true,
include_roles: [
'0000000000'
]
});
Field |
Type |
Description |
guild_id |
snowflake |
the id of the guild |
await mapih.discord.guilds.getVoiceRegions({
guild_id: '0000000000'
});
This endpoint returns a maximum of 50 integrations.
If a guild has more integrations, they cannot be accessed.
Field |
Type |
Description |
guild_id |
snowflake |
the id of the guild |
await mapih.discord.guilds.getAllIntegrations({
guild_id: '0000000000'
});
• Deletes any associated webhooks and kicks the associated bot if there is one.
Field |
Type |
Description |
guild_id |
snowflake |
the id of the guild |
integration_id |
snowflake |
The ID of the integration to delete |
await mapih.discord.guilds.destroyIntegration({
guild_id: '0000000000'
});
Field |
Type |
Description |
guild_id |
snowflake |
the id of the guild |
await mapih.discord.guilds.retrieveWidget({
guild_id: '0000000000'
});
Field |
Type |
Description |
guild_id |
snowflake |
the id of the guild |
await mapih.discord.guilds.retrieveWidgetSettings({
guild_id: '0000000000'
});
Value |
Description |
Example |
shield |
shield style widget with Discord icon and guild members online count |
Example |
banner1 |
large image with guild icon, name and online count. "POWERED BY DISCORD" as the footer of the widget |
Example |
banner2 |
smaller widget style with guild icon, name and online count. Split on the right with Discord logo |
Example |
banner3 |
large image with guild icon, name and online count. In the footer, Discord logo on the left and "Chat Now" on the right |
Example |
banner4 |
large Discord logo at the top of the widget. Guild icon, name and online count in the middle portion of the widget and a "JOIN MY SERVER" button at the bottom |
Example |
Field |
Type |
Description |
guild_id |
snowflake |
the id of the guild |
style |
string |
Widget style (see above) |
await mapih.discord.guilds.retrieveWidgetImage({
guild_id: '0000000000',
style: 'banner3'
});
Field |
Type |
Description |
guild_id |
snowflake |
the id of the guild |
channel_id? |
snowflake |
temp |
enabled? |
boolean |
Whether the widget is enabled |
await mapih.discord.guilds.updateWidget({
guild_id: '0000000000',
enabled: true
});
Field |
Type |
Description |
guild_id |
snowflake |
the id of the guild |
await mapih.discord.guilds.retrieveVanityURL({
guild_id: '0000000000'
});
Field |
Type |
Description |
guild_id |
snowflake |
the id of the guild |
await mapih.discord.guilds.retrieveWelcomeScreen({
guild_id: '0000000000'
});
Field |
Type |
Description |
guild_id |
snowflake |
the id of the guild |
description? |
string |
The server description to show in the welcome screen |
enabled? |
boolean |
Whether the welcome screen is enabled. |
welcome_channels? |
array of welcome screen channel objects |
Channels shown in the welcome screen, up to 5 |
await mapih.discord.guilds.updateWelcomeScreen({
guild_id: '0000000000',
enabled: true
});
Field |
Type |
Description |
guild_id |
snowflake |
the id of the guild |
await mapih.discord.guilds.retrieveOnboarding({
guild_id: '0000000000',
enabled: true
});
• Requires the MANAGE_GUILD
and MANAGE_ROLES
permissions.
• Onboarding enforces constraints when enabled. These constraints are that there must be at least 7 Default Channels and at least 5 of them must allow sending messages to the @everyone role. The mode field modifies what is considered when enforcing these constraints.**
Field |
Type |
Description |
guild_id |
snowflake |
the id of the guild |
prompts |
array of onboarding prompt objects |
Prompts shown during onboarding and in customize commutity |
default_channel_ids |
array of snowflakes |
Channel IDs that members get opted into automatically |
enabled |
boolean |
Whether onboarding is enabled in the guild |
mode |
onboarding mode |
Current mode of onboarding |
await mapih.discord.guilds.updateOnboarding({
guild_id: '0000000000',
prompts: [{
id: '0000000000',
type: 0,
title: 'Prompt Title',
single_select: true,
required: true,
in_onboarding: true,
options: [{
title: 'Option Title',
description: 'Option description',
id: '0000000000',
channel_ids: [
'0000000000'
],
role_ids: [
'0000000000'
],
emoji: {
id: '0000000000',
name: 'emoji_name',
animated: false
}
}]
}]
});
Method |
Description |
getAll |
Retrieve all channels in a guild. |
create |
Create a new guild channel. |
updatePositions |
Modify the positions of channels. |
Field |
Type |
Description |
guild_id |
snowflake |
the id of the guild |
await mapih.discord.guilds.channels.getAll({
guild_id: '0000000000'
});
All parameters to this endpoint are optional and nullable excluding name
Field |
Type |
Description |
Channel Type |
name |
string |
channel name (1-100 characters) |
All |
type |
number |
the type of channel
|
All |
topic |
string |
channel topic (0-1024 characters) |
Text, Announcement, Forum, Media |
bitrate |
number |
the bitrate (in bits) of the voice or stage channel; min 8000 |
Voice, Stage |
user_limit |
number |
the user limit of the voice channel |
Voice, Stage |
rate_limit_per_user |
number |
amount of seconds a user has to wait before sending another message (0-21600); bots, as well as users with the permission manage_messages or manage_channel , are unaffected |
Text, Voice, Stage, Forum, Media |
position |
number |
sorting position of the channel |
All |
permission_overwrites |
array of partial overwrite objects |
the channel's permission overwrites |
All |
parent_id |
snowflake |
id of the parent category for a channel |
Text, Voice, Announcement, Stage, Forum, Media |
nsfw |
boolean |
whether the channel is nsfw |
Text, Voice, Announcement, Stage, Forum |
rtc_region |
string |
channel voice region id of the voice or stage channel, automatic when set to null |
Voice, Stage |
video_quality_mode |
number |
the camera video quality mode of the voice channel |
Voice, Stage |
default_auto_archive_duration |
number |
the default duration that the clients use (not the API) for newly created threads in the channel, in minutes, to automatically archive the thread after recent activity |
Text, Announcement, Forum, Media |
default_reaction_emoji |
default reaction object |
emoji to show in the add reaction button on a thread in a GUILD_FORUM or a GUILD_MEDIA channel |
Forum, Media |
available_tags |
array of tag objects |
set of tags that can be used in a GUILD_FORUM or a GUILD_MEDIA channel |
Forum, Media |
default_sort_order |
number |
the default sort order type used to order posts in GUILD_FORUM and GUILD_MEDIA channels |
Forum, Media |
default_forum_layout |
number |
the default forum layout view used to display posts in GUILD_FORUM channels |
Forum |
default_thread_rate_limit_per_user |
number |
the initial rate_limit_per_user to set on newly created threads in a channel. this field is copied to the thread at creation time and does not live update. |
Text, Announcement, Forum, Media |
await mapih.discord.guilds.channels.create({
guild_id: '0000000000',
name: 'my-new-channel',
type: 0,
topic: 'Cool people only',
position: 19
});
Only channels to be modified are required
Field |
Type |
Description |
id |
snowflake |
channel id |
position? |
?number |
sorting position of the channel |
lock_permissions? |
?boolean |
syncs the permission overwrites with the new parent, if moving to a new category |
parent_id? |
?snowflake |
the new parent ID for the channel that is moved |
await mapih.discord.guilds.channels.updatePositions({
guild_id: '0000000000',
channels: [{
id: '0000000000',
position: 3,
lock_permissions: true,
parent_id: '0000000000'
}]
});
Method |
Description |
retrieve |
Returns information about a user |
getAll |
List all members of a guild |
search |
Search for guild members by name or nickname |
remove |
Remove a member from a guild |
update |
Modify attributes of a guild member |
updateCurrent |
Modify the current bot's nickname in the guild |
addRole |
Add a role to a guild member |
removeRole |
Remove a role from a guild member |
getPermissionNames |
Get a user's permission's names |
timeout |
Update a member's communication timeout |
Field |
Type |
Description |
guild_id |
snowflake |
the id of the guild |
user_id |
snowflake |
The ID of the user |
await mapih.discord.guilds.members.retrieve({
guild_id: '0000000000',
user_id: '0000000000'
});
Field |
Type |
Description |
guild_id |
snowflake |
the id of the guild |
limit |
number |
Max number of members to return (1-1000) (default 1) |
after |
snowflake |
The highest user id in the previous page (default 0) |
await mapih.discord.guilds.members.getAll({
guild_id: '0000000000',
limit: 1000
});
Field |
Type |
Description |
guild_id |
snowflake |
the id of the guild |
query |
string |
Query string to match username(s) and nickname(s) against |
limit |
number |
Max number of members to return (1-1000) (default 1) |
await mapih.discord.guilds.members.search({
guild_id: '0000000000',
query: 'lostmyinfo',
limit: 1
});
Field |
Type |
Description |
guild_id |
snowflake |
the id of the guild |
user_id |
snowflake |
The ID of the user to remove |
reason? |
string |
Reason for kick |
await mapih.discord.guilds.members.remove({
guild_id: '0000000000',
user_id: '0000000000',
reason: 'not cool enough'
});
• If the channel_id is set to null, this will force the target user to be disconnected from voice.
All parameters to this endpoint are optional and nullable.
Field |
Type |
Description |
Permission |
guild_id |
snowflake |
the id of the guild |
|
role_id |
snowflake |
the id of the role |
|
nick |
string |
value to set user's nickname to |
MANAGE_NICKNAMES |
roles |
array of snowflakes |
array of role ids the member is assigned |
MANAGE_ROLES |
mute |
boolean |
whether the user is muted in voice channels |
MUTE_MEMBERS |
deaf |
boolean |
whether the user is deafened in voice channels |
DEAFEN_MEMBERS |
channel_id |
snowflake |
id of channel to move user to (if they are connected to voice) |
MOVE_MEMBERS |
communication_disabled_until |
ISO8601 timestamp |
when the user's timeout will expire (up to 28 days in the future) |
MODERATE_MEMBERS |
flags |
number |
guild member flags |
MODERATE_MEMBERS |
await mapih.discord.guilds.members.update({
guild_id: '0000000000',
nick: 'cool new nick'
});
Field |
Type |
Description |
guild_id |
snowflake |
the id of the guild |
nick? |
string |
Value to set user's nickname to |
await mapih.discord.guilds.members.updateCurrent({
guild_id: '0000000000',
nick: 'cool new nick'
});
Field |
Type |
Description |
guild_id |
snowflake |
the id of the guild |
user_id |
snowflake |
The user ID of the user to assign the role to |
role_id |
snowflake |
The role ID of the role to give the user |
await mapih.discord.guilds.members.addRole({
guild_id: '0000000000',
user_id: '0000000000',
role_id: '0000000000'
});
Field |
Type |
Description |
guild_id |
snowflake |
the id of the guild |
user_id |
snowflake |
The user ID of the user to remove the role from |
role_id |
snowflake |
The role ID of the role to remove from the user |
await mapih.discord.guilds.members.removeRole({
guild_id: '0000000000',
user_id: '0000000000',
role_id: '0000000000'
});
Get Member Permission Names
Type |
Description |
array of role IDs |
Roles of a member |
array of role objects |
Roles of a guild |
const x = params.member.roles;
const y = params.guild.roles;
const permNames = getPermissionNames(x, y);
• Sets/adjusts/clears a member's timeout
Field |
Type |
Description |
guild_id |
snowflake |
the id of the guild |
user_id |
snowflake |
The user ID of the user to remove the role from |
duration |
number |
Duration in seconds to set timeout. Set to null or omit to clear timeout. |
reason? |
string |
Reason |
// timeout a member for 5 minutes
await mapih.discord.guilds.members.timeout({
guild_id: '0000000000',
user_id: '0000000000',
duration: 300 // 5 minutes
});
// clear a member's timeout
await mapih.discord.guilds.members.timeout({
guild_id: '0000000000',
user_id: '0000000000'
});
Method |
Description |
retrieve |
Retrieve a role by ID |
getAll |
List all roles in a guild |
create |
Create a new role in the guild |
update |
Modify properties of a guild role |
destroy |
Modify properties of a guild role |
Field |
Type |
Description |
guild_id |
snowflake |
the id of the guild |
role_id |
snowflake |
the id of the role |
await mapih.discord.guilds.roles.retrieve({
guild_id: '0000000000',
role_id: '0000000000'
});
Field |
Type |
Description |
guild_id |
snowflake |
the id of the guild |
await mapih.discord.guilds.roles.getAll({
guild_id: '0000000000'
});
Field |
Type |
Description |
Default |
guild_id |
snowflake |
the id of the guild |
|
role_id |
snowflake |
the id of the role |
|
name |
string |
name of the role, max 100 characters |
"new role" |
permissions |
string |
bitwise value of the enabled/disabled permissions |
@everyone |
color |
number |
RGB color value |
0 |
hoist |
boolean |
whether the role should be displayed separately in the sidebar |
false |
icon |
url/buffer |
the role's icon image (if the guild has the ROLE_ICONS feature) |
null |
unicode_emoji |
?string |
the role's unicode emoji as a standard emoji (if guild has the ROLE_ICONS feature) |
null |
mentionable |
boolean |
whether the role should be mentionable |
false |
await mapih.discord.guilds.roles.create({
guild_id: '0000000000',
name: 'cool kids',
hoist: true,
mentionable: true,
icon: 'https://www.picofcoolkid.png'
});
All parameters to this endpoint are optional and nullable.
Field |
Type |
Description |
guild_id |
snowflake |
the id of the guild |
role_id |
snowflake |
the id of the role |
name |
string |
name of the role, max 100 characters |
permissions |
string |
bitwise value of the enabled/disabled permissions |
color |
number |
RGB color value |
hoist |
boolean |
whether the role should be displayed separately in the sidebar |
icon |
url/buffer |
the role's icon image (if the guild has the ROLE_ICONS feature) |
unicode_emoji |
?string |
the role's unicode emoji as a standard emoji (if guild has the ROLE_ICONS feature) |
mentionable |
boolean |
whether the role should be mentionable |
await mapih.discord.guilds.roles.update({
guild_id: '0000000000',
role_id: '0000000000',
name: 'new role name',
hoist: false,
mentionable: false,
icon: 'https://www.newimage.png'
});
Field |
Type |
Description |
guild_id |
snowflake |
the id of the guild |
role_id |
snowflake |
the id of the role |
reason? |
string |
reason |
await mapih.discord.guilds.roles.destroy({
guild_id: '0000000000',
role_id: '0000000000'
});
Modify Guild Role Positions
Field |
Type |
Description |
guild_id |
snowflake |
the id of the guild |
roles |
array of partial channel objects |
the ids and new positions of the channels to modify |
await mapih.discord.guilds.roles.retrieve({
guild_id: '0000000000',
roles: [
{ id: '0000000000', position: 3 },
{ id: '0000000000', position: 8 }
]
});
Method |
Description |
retrieve |
Get a specific emoji from a guild |
getAll |
List all emojis in a guild |
create |
Create a new emoji in the guild |
update |
Modify a guild emoji |
destroy |
Delete a guild emoji |
Field |
Type |
Description |
guild_id |
snowflake |
the id of the guild |
emoji_id |
snowflake |
The id of the emoji |
await mapih.discord.guilds.emojis.retrieve({
guild_id: '0000000000',
emoji_id: '0000000000'
});
Field |
Type |
Description |
guild_id |
snowflake |
the id of the guild |
await mapih.discord.guilds.emojis.getAll({
guild_id: '0000000000'
});
Field |
Type |
Description |
guild_id |
snowflake |
the id of the guild |
name |
string |
name of the emoji |
image |
url/buffer |
the 128x128 emoji image |
roles |
array of snowflakes |
roles allowed to use this emoji |
await mapih.discord.guilds.emojis.create({
guild_id: '0000000000',
name: 'goodsie',
image: 'https://picofgoodsie.png'
});
Field |
Type |
Description |
guild_id |
snowflake |
the id of the guild |
emoji_id |
snowflake |
the id of the emoji |
name |
string |
name of the emoji |
roles |
array of snowflakes |
roles allowed to use this emoji |
await mapih.discord.guilds.emojis.update({
guild_id: '0000000000',
emoji_id: '0000000000',
name: 'newemojiname'
});
Field |
Type |
Description |
guild_id |
snowflake |
the id of the guild |
emoji_id |
snowflake |
The id of the emoji |
await mapih.discord.guilds.emojis.destroy({
guild_id: '0000000000',
emoji_id: '0000000000'
});
Field |
Type |
Description |
sticker_id |
snowflake |
The id of the sticker |
await mapih.discord.guilds.stickers.retrieve({
sticker_id: '0000000000'
});
Field |
Type |
Description |
guild_id |
snowflake |
the id of the guild |
sticker_id |
snowflake |
The id of the sticker |
await mapih.discord.guilds.stickers.retrieveGuild({
guild_id: '0000000000',
sticker_id: '0000000000'
});
await mapih.discord.guilds.stickers.retrieve();
Field |
Type |
Description |
guild_id |
snowflake |
the id of the guild |
await mapih.discord.guilds.stickers.getAll({
guild_id: '0000000000'
});
This endpoint may take time. It goes through multiple functions before returning the sticker.
Field |
Type |
Description |
guild_id |
snowflake |
the id of the guild |
name |
string |
name of the sticker (2-30 characters) |
description |
string |
description of the sticker (empty or 2-100 characters) |
tags |
string |
autocomplete/suggestion tags for the sticker (max 200 characters) |
file |
url/buffer |
the sticker file to upload |
await mapih.discord.guilds.stickers.create({
guild_id: '0000000000',
name: 'mynewsticker',
description: 'cool description',
tags: 'uhhh',
file: 'https://uhhh.gif'
});
Field |
Type |
Description |
guild_id |
snowflake |
the id of the guild |
name |
string |
name of the sticker (2-30 characters) |
description |
string |
description of the sticker (empty or 2-100 characters) |
tags |
string |
autocomplete/suggestion tags for the sticker (max 200 characters) |
await mapih.discord.guilds.stickers.update({
guild_id: '0000000000',
name: 'mynewnewsticker',
description: 'new cool description',
tags: 'new uhhh',
});
Field |
Type |
Description |
guild_id |
snowflake |
the id of the guild |
sticker_id |
string |
the id of the sticker |
await mapih.discord.guilds.stickers.destroy({
guild_id: '0000000000',
sticker_id: '0000000000',
});
Method |
Description |
retrieve |
Get a specific scheduled event in the guild |
getAll |
List all scheduled events for the guild |
getUsers |
Get users subscribed to a scheduled event |
create |
Create a new scheduled event in the guild |
update |
Modify a guild scheduled event |
destroy |
Delete a guild scheduled event |
Field |
Type |
Description |
guild_id |
snowflake |
the id of the guild |
guild_scheduled_event_id |
snowflake |
the id of the event |
with_user_count? |
boolean |
include number of users subscribed to each event |
await mapih.discord.guilds.events.retrieve({
guild_id: '0000000000',
guild_scheduled_event_id: '0000000000',
with_user_count: true
});
Field |
Type |
Description |
guild_id |
snowflake |
the id of the guild |
with_user_count? |
boolean |
include number of users subscribed to each event |
await mapih.discord.guilds.events.getAll({
guild_id: '0000000000',
with_user_count: true
});
Field |
Type |
Description |
Default |
guild_id |
snowflake |
the id of the guild |
|
guild_scheduled_event_id |
snowflake |
the id of the event |
|
limit? |
number |
number of users to return (up to maximum 100) |
100 |
with_member? |
boolean |
include guild member data if it exists |
false |
before? * |
snowflake |
consider only users before given user id |
null |
after? * |
snowflake |
consider only users after given user id |
null |
* Provide a user id to before
and after
for pagination. Users will always be returned in ascending order by user_id
.
If both before
and after
are provided, only before
is respected. Fetching users in-between before
and after
is not supported.**
await mapih.discord.guilds.events.getUsers({
guild_id: '0000000000',
guild_scheduled_event_id: '0000000000',
limit: 10,
with_member: true
});
Field |
Type |
Description |
guild_id |
snowflake |
|
channel_id? * |
?snowflake |
Set to null if changing entity type to EXTERNAL
|
entity_metadata? ** |
entity metadata |
The entity metadata of the scheduled event |
name |
string |
The name of the scheduled event |
privacy_level |
privacy level |
The privacy level of the scheduled event |
scheduled_start_time |
ISO8601 timestamp |
The time to schedule the scheduled event |
scheduled_end_time? ** |
ISO8601 timestamp |
The time when the scheduled event is scheduled to end |
description? |
string |
The description of the scheduled event |
entity_type |
event entity type |
The entity type of the scheduled event |
image? |
url/buffer |
The cover image of the scheduled event |
* Optional for events with 'entity_type': EXTERNAL
** Required for events with 'entity_type': EXTERNAL
await mapih.discord.guilds.events.create({
guild_id: '0000000000',
name: 'Cool Event Name',
privacy_level: 2,
scheduled_start_time: '2023-04-04T11:00:00',
entity_type: 2,
channel_id: '0000000000'
});
Field |
Type |
Description |
guild_id |
snowflake |
|
channel_id? * |
?snowflake |
Set to null if changing entity type to EXTERNAL
|
entity_metadata? |
?entity metadata
|
The entity metadata of the scheduled event |
name? |
string |
The name of the scheduled event |
privacy_level? |
privacy level |
The privacy level of the scheduled event |
scheduled_start_time? |
ISO8601 timestamp |
The time to schedule the scheduled event |
scheduled_end_time? * |
ISO8601 timestamp |
The time when the scheduled event is scheduled to end |
description? |
?string |
The description of the scheduled event |
entity_type? * |
event entity type |
The entity type of the scheduled event |
status? |
event status |
The status of the scheduled event |
image? |
url/buffer |
The cover image of the scheduled event |
* If updating entity_type
to EXTERNAL
:
-
channel_id
is required and must be set to null
-
entity_metadata
with a location
field must be provided
-
scheduled_end_time
must be provided
await mapih.discord.guilds.events.update({
guild_id: '0000000000',
guild_scheduled_event_id: '0000000000'
name: 'Edited Event Name',
status: 2 // ACTIVE
});
Field |
Type |
Description |
guild_id |
snowflake |
the id of the guild |
await mapih.discord.guilds.events.destroy({
guild_id: '0000000000'
});
Method |
Description |
retrieve |
Get a guild template by its code |
getAll |
List all templates for a guild |
create |
Create a new template for the guild |
createGuild |
Create a new guild from a template |
sync |
Sync a guild template with the guild's current state |
update |
Modify a guild template |
destroy |
Delete a guild template |
Field |
Type |
Description |
template_code |
snowflake |
the template's code |
await mapih.discord.guilds.templates.retrieve({
template_code: '0000000000'
});
Field |
Type |
Description |
guild_id |
snowflake |
the guild id |
await mapih.discord.guilds.templates.getAll({
guild_id: '0000000000'
});
Field |
Type |
Description |
guild_id |
snowflake |
the guild's id |
name |
string |
name of the template (1-100 characters) |
description? |
?string |
description for the template (0-120 characters) |
await mapih.discord.guilds.templates.create({
guild_id: '0000000000',
name: 'fancy template'
});
Field |
Type |
Description |
guild_id |
snowflake |
the guild's id |
template_code |
snowflake |
the template's code |
name? |
string |
name of the template (1-100 characters) |
description? |
?string |
description for the template (0-120 characters) |
await mapih.discord.guilds.templates.update({
guild_id: '0000000000',
template_code: '0000000000',
name: 'new fancy template name'
});
Field |
Type |
Description |
guild_id |
snowflake |
the guild id |
template_code |
snowflake |
the template's code |
await mapih.discord.guilds.templates.destroy({
guild_id: '0000000000',
template_code: '0000000000'
});
This endpoint can be used only by bots in less than 10 guilds.
Field |
Type |
Description |
guild_id |
snowflake |
the guild's id |
template_code |
snowflake |
the template's code |
name |
string |
name of the template (1-100 characters) |
icon? |
url/buffer |
image url or image buffer for the guild's icon |
await mapih.discord.guilds.templates.createGuild({
template_code: '0000000000',
name: 'Eric\'s cool server template',
icon: 'https://templateGuildIcon.png'
});
Field |
Type |
Description |
guild_id |
snowflake |
the guild id |
template_code |
snowflake |
the template's code |
await mapih.discord.guilds.templates.sync({
guild_id: '0000000000',
template_code: '0000000000'
});
All functions relating to Discord Channels
Field |
Type |
Description |
channel_id |
snowflake |
the id of the channel |
await mapih.discord.channels.retrieve({
channel_id: '0000000000'
});
Field |
Type |
Description |
Channel Type |
channel_id |
snowflake |
the id of the channel |
|
name |
string |
1-100 character channel name |
All |
type |
number |
the type of channel; only conversion between text and announcement is supported and only in guilds with the "NEWS" feature |
Text, Announcement |
position |
?number |
the position of the channel in the left-hand listing |
All |
topic |
?string |
0-1024 character channel topic (0-4096 characters for GUILD_FORUM and GUILD_MEDIA channels) |
Text, Announcement, Forum, Media |
nsfw |
?boolean |
whether the channel is nsfw |
Text, Voice, Announcement, Stage, Forum, Media |
rate_limit_per_user |
?number |
amount of seconds a user has to wait before sending another message (0-21600); bots, as well as users with the permission manage_messages or manage_channel , are unaffected |
Text, Voice, Stage, Forum, Media |
bitrate* |
?number |
the bitrate (in bits) of the voice or stage channel; min 8000 |
Voice, Stage |
user_limit |
?number |
the user limit of the voice or stage channel, max 99 for voice channels and 10,000 for stage channels (0 refers to no limit) |
Voice, Stage |
permission_overwrites** |
?array of partial overwrite objects |
channel or category-specific permissions |
All |
parent_id |
?snowflake |
id of the new parent category for a channel |
Text, Voice, Announcement, Stage, Forum, Media |
rtc_region |
?string |
channel voice region id, automatic when set to null |
Voice, Stage |
video_quality_mode |
?number |
the camera video quality mode of the voice channel |
Voice, Stage |
default_auto_archive_duration |
?number |
the default duration that the clients use (not the API) for newly created threads in the channel, in minutes, to automatically archive the thread after recent activity |
Text, Announcement, Forum, Media |
flags? |
number |
channel flags combined as a bitfield. Currently only REQUIRE_TAG (1 << 4 ) is supported by GUILD_FORUM and GUILD_MEDIA channels. HIDE_MEDIA_DOWNLOAD_OPTIONS (1 << 15 ) is supported only by GUILD_MEDIA channels |
Forum, Media |
available_tags? |
array of tag objects |
the set of tags that can be used in a GUILD_FORUM or a GUILD_MEDIA channel; limited to 20 |
Forum, Media |
default_reaction_emoji? |
?default reaction object |
the emoji to show in the add reaction button on a thread in a GUILD_FORUM or a GUILD_MEDIA channel |
Forum, Media |
default_thread_rate_limit_per_user? |
number |
the initial rate_limit_per_user to set on newly created threads in a channel. this field is copied to the thread at creation time and does not live update. |
Text, Forum, Media |
default_sort_order? |
?number |
the default sort order type used to order posts in GUILD_FORUM and GUILD_MEDIA channels |
Forum, Media |
default_forum_layout? |
number |
the default forum layout type used to display posts in GUILD_FORUM channels |
Forum |
* For voice channels, normal servers can set bitrate up to 96000, servers with Boost level 1 can set up to 128000, servers with Boost level 2 can set up to 256000, and servers with Boost level 3 or the VIP_REGIONS
guild feature can set up to 384000. For stage channels, bitrate can be set up to 64000.
** In each overwrite object, the allow
and deny
keys can be omitted or set to null
, which both default to "0"
.
• When setting archived
to false
, when locked
is also false
, only the SEND_MESSAGES
permission is required.
• Otherwise, requires the MANAGE_THREADS
permission.
Field |
Type |
Description |
name |
string |
1-100 character channel name |
archived |
boolean |
whether the thread is archived |
auto_archive_duration |
number |
the thread will stop showing in the channel list after auto_archive_duration minutes of inactivity, can be set to: 60, 1440, 4320, 10080 |
locked |
boolean |
whether the thread is locked; when a thread is locked, only users with MANAGE_THREADS can unarchive it |
invitable |
boolean |
whether non-moderators can add other non-moderators to a thread; only available on private threads |
rate_limit_per_user |
?number |
amount of seconds a user has to wait before sending another message (0-21600); bots, as well as users with the permission manage_messages , manage_thread , or manage_channel , are unaffected |
flags? |
number |
channel flags; PINNED can only be set for threads in forum and media channels |
applied_tags? |
array of snowflakes |
the IDs of the set of tags that have been applied to a thread in a GUILD_FORUM or a GUILD_MEDIA channel; limited to 5 |
await mapih.discord.channels.update({
channel_id: '0000000000',
name: 'new-name'
});
Field |
Type |
Description |
channel_id |
snowflake |
the id of the channel |
await mapih.discord.channels.destroy({
channel_id: '0000000000'
});
Field |
Type |
Description |
channel_id |
snowflake |
the id of the channel |
allow? |
string? |
the bitwise value of all allowed permissions (default "0" ) |
deny? |
string? |
the bitwise value of all disallowed permissions (default "0" ) |
type |
number |
0 for a role or 1 for a member |
await mapih.discord.channels.editPermissions({
channel_id: '0000000000',
overwrite_id: '0000000000',
type: 1, // member
allow: '1024'
});
Field |
Type |
Description |
channel_id |
snowflake |
the id of the channel |
await mapih.discord.channels.deletePermissions({
channel_id: '0000000000'
});
Field |
Type |
Description |
channel_id |
snowflake |
the id of the channel |
await mapih.discord.channels.getInvites({
channel_id: '0000000000'
});
Field |
Type |
Description |
channel_id |
snowflake |
the id of the channel |
uses |
number |
number of times this invite has been used |
max_uses |
number |
max number of times this invite can be used |
max_age |
number |
duration (in seconds) after which the invite expires |
temporary |
boolean |
whether this invite only grants temporary membership |
created_at |
ISO8601 timestamp |
when this invite was created |
await mapih.discord.channels.inviteCreate({
channel_id: '0000000000',
max_age: 7200,
max_uses: 1
});
Field |
Type |
Description |
channel_id |
snowflake |
the id of the channel |
await mapih.discord.channels.typingCreate({
channel_id: '0000000000'
});
Field |
Type |
Description |
channel_id |
snowflake |
the id of the channel to send announcements to |
webhook_channel_id |
snowflake |
the id of the target channel |
await mapih.discord.channels.followAnnouncementChannel({
channel_id: '0000000000',
webhook_channel_id: '0000000000'
});
Field |
Type |
Description |
channel_id |
snowflake |
the id of the channel to send announcements to |
user_id |
snowflake |
the id of the channel to send announcements to |
access_token |
string |
access token of a user that has granted your app the gdm.join scope |
nick |
string |
nickname of the user being added |
await mapih.discord.channels.groupDMadd({
channel_id: '0000000000',
user_id: '0000000000',
access_token: 'abcdef123456',
nick: 'userNickname'
});
Field |
Type |
Description |
channel_id |
snowflake |
the id of the channel to send announcements to |
user_id |
snowflake |
the id of the user to remove |
await mapih.discord.channels.groupDMremove({
channel_id: '0000000000',
user_id: '0000000000'
});
Field |
Type |
Description |
channel_id |
snowflake |
the id of the channel |
message_id |
snowflake |
the id of the message |
await mapih.discord.channels.messages.retrieve({
channel_id: '0000000000',
message_id: '0000000000'
});
Field |
Type |
Description |
channel_id |
snowflake |
the id of the channel |
around? |
snowflake |
Get messages around this message ID |
before? |
snowflake |
Get messages before this message ID |
after? |
snowflake |
Get messages after this message ID |
limit? |
number |
Max number of messages to return (1-100) (default 50) |
The before
, after
, and around
parameters are mutually exclusive, only one may be passed at a time.
await mapih.discord.channels.messages.getAll({
channel_id: '0000000000',
limit: 50
});
To create a message as a reply to another message, apps can include a message_reference with a message_id
.
• The channel_id
and guild_id
in the message_reference
are optional, but will be validated if provided.
Field |
Type |
Description |
channel_id |
snowflake |
Channel id of the channel to send the message to |
content?* |
string |
Message contents (up to 2000 characters) |
tts? |
boolean |
true if this is a TTS message |
embeds?* |
array of embed objects |
Up to 10 rich embeds (up to 6000 characters) |
allowed_mentions? |
allowed mention object |
Allowed mentions for the message |
message_reference? |
message reference |
Include to make your message a reply |
components?* |
array of message component objects |
Components to include with the message |
sticker_ids?* |
array of snowflakes |
IDs of up to 3 stickers in the server to send in the message |
attachments? |
array of partial attachment objects |
Attachment objects with filename and description. |
flags? |
number |
Message flags (only SUPPRESS_EMBEDS and SUPPRESS_NOTIFICATIONS can be set) |
* At least one of content
, embeds
, sticker_ids
, components
, or files[n]
is required.
await mapih.discord.channels.messages.create({
channel_id: '0000000000',
content: 'sup'
});
await mapih.discord.channels.messages.create({
channel_id: '0000000000',
content: '',
embeds: [{
title: 'embed title',
description: 'embed description'
}],
components: [{
type: 1,
components: [{
type: 2, // button
style: 1,
label: 'buttonLabel',
custom_id: 'asdfghjkl'
}]
}]
});
await mapih.discord.channels.messages.create({
channel_id: '0000000000',
content: 'this will surprese all mentions',
allowed_mentions: {
parse: []
}
});
Field |
Type |
Description |
channel_id |
snowflake |
the id of the channel the message is in |
message_id |
snowflake |
the id of the message to edit |
content? |
string |
Message contents (up to 2000 characters) |
embeds? |
array of embed objects |
Up to 10 rich embeds (up to 6000 characters) |
allowed_mentions? |
allowed mention object |
Allowed mentions for the message |
message_reference? |
message reference |
Include to make your message a reply |
components? |
array of message component objects |
Components to include with the message |
attachments? |
array of partial attachment objects |
Attachment objects with filename and description. |
flags? |
number |
Message flags (only SUPPRESS_EMBEDS and SUPPRESS_NOTIFICATIONS can be set) |
• When the content field is edited, the mentions array in the message object will be reconstructed from scratch based on the new content.
• The allowed_mentions field of the edit request controls how this happens.
• If there is no explicit allowed_mentions in the edit request, the content will be parsed with default allowances, that is, without regard to whether or not an allowed_mentions was present in the request that originally created the message.
• The attachments array must contain all attachments that should be present after edit, including retained and new attachments.
await mapih.discord.channels.messages.update({
channel_id: '0000000000',
message_id: '0000000000',
content: 'new message'
});
Field |
Type |
Description |
channel_id |
snowflake |
the id of the channel |
message_id |
snowflake |
the id of the message |
await mapih.discord.channels.messages.destroy({
channel_id: '0000000000',
message_id: '0000000000'
});
• Any message IDs given that do not exist or are invalid will count towards the minimum and maximum message count (currently 2 and 100 respectively).
This endpoint will not delete messages older than 2 weeks.
Field |
Type |
Description |
channel_id |
snowflake |
the id of the channel |
messages |
array of snowflakes |
an array of message ids to delete (2-100) |
await mapih.discord.channels.messages.bulkDelete({
channel_id: '0000000000',
messages: [
'0000000000',
'0000000000'
]
});
Field |
Type |
Description |
channel_id |
snowflake |
the id of the channel |
message_id |
snowflake |
the message id of the message to crosspost |
await mapih.discord.channels.messages.crosspost({
channel_id: '0000000000',
message_id: '0000000000'
});
Field |
Type |
Description |
channel_id |
snowflake |
the id of the channel |
message_id |
snowflake |
the message id of the message to pin |
await mapih.discord.channels.messages.pin({
channel_id: '0000000000',
message_id: '0000000000'
});
Field |
Type |
Description |
channel_id |
snowflake |
the id of the channel |
message_id |
snowflake |
the message id of the message to unpin |
await mapih.discord.channels.messages.unpin({
channel_id: '0000000000',
message_id: '0000000000'
});
Field |
Type |
Description |
channel_id |
snowflake |
the id of the channel |
await mapih.discord.channels.messages.getPinned({
channel_id: '0000000000'
});
All functions relating to Discord Threads
Field |
Type |
Description |
channel_id |
snowflake |
the id of the channel |
name |
string |
1-100 character channel name |
auto_archive_duration?* |
integer |
duration in minutes to automatically archive the thread after recent activity, can be set to: 60, 1440, 4320, 10080 |
rate_limit_per_user? |
?integer |
amount of seconds a user has to wait before sending another message (0-21600) |
message |
forum thread message params object |
contents of the first message in the forum/media thread |
applied_tags? |
array of snowflakes |
the IDs of the set of tags that have been applied to a thread in a GUILD_FORUM or a GUILD_MEDIA channel |
await mapih.discord.channels.threads.forumThreadCreate({
channel_id: '0000000000',
name: 'thread name',
message: {
content: 'new message',
embeds: [{
title: 'example',
description: 'example'
}]
},
auto_archive_duration: 4320
});
• When called on a GUILD_TEXT
channel, creates a PUBLIC_THREAD
.
• When called on a GUILD_ANNOUNCEMENT
channel, creates an ANNOUNCEMENT_THREAD
.
• Does not work on a GUILD_FORUM
channel.
• The ID of the created thread will be the same as the ID of the source message, and as such a message can only have a single thread created from it.
Field |
Type |
Description |
channel_id |
snowflake |
the id of the channel |
message_id |
snowflake |
the id of the message to create the thread from |
name |
string |
1-100 character channel name |
auto_archive_duration? |
number |
duration in minutes to automatically archive the thread after recent activity, can be set to: 60, 1440, 4320, 10080 |
rate_limit_per_user? |
?number |
amount of seconds a user has to wait before sending another message (0-21600) |
await mapih.discord.channels.threads.createFromMessage({
channel_id: '0000000000',
message_id: '0000000000',
name: 'thread name',
auto_archive_duration: 10080
});
Field |
Type |
Description |
channel_id |
snowflake |
the id of the channel |
name |
string |
1-100 character channel name |
type? * |
number |
the type of thread to create |
invitable? * |
boolean |
whether non-moderators can add other non-moderators to a thread; only available when creating a private thread |
rate_limit_per_user? |
?number |
amount of seconds a user has to wait before sending another message (0-21600) |
* type
currently defaults to PRIVATE_THREAD
in order to match the behavior when thread documentation was first published.
await mapih.discord.channels.threads.createWithoutMessage({
channel_id: '0000000000',
type: 11, // PUBLIC_THREAD
name: 'thread name',
auto_archive_duration: 10080,
invitable: true
});
Field |
Type |
Description |
channel_id |
snowflake |
the id of the channel |
await mapih.discord.channels.threads.join({
channel_id: '0000000000'
});
Field |
Type |
Description |
channel_id |
snowflake |
the id of the channel |
await mapih.discord.channels.threads.leave({
channel_id: '0000000000'
});
Field |
Type |
Description |
channel_id |
snowflake |
the id of the channel |
user_id |
snowflake |
the id of the user to add |
await mapih.discord.channels.threads.addMember({
channel_id: '0000000000',
user_id: '0000000000'
});
Field |
Type |
Description |
channel_id |
snowflake |
the id of the channel |
user_id |
snowflake |
the id of the user to add |
await mapih.discord.channels.threads.removeMember({
channel_id: '0000000000',
user_id: '0000000000'
});
Field |
Type |
Description |
channel_id |
snowflake |
the id of the channel |
user_id |
snowflake |
the id of the user to add |
with_member? |
boolean |
whether to include a guild member object |
await mapih.discord.channels.threads.retrieveMember({
channel_id: '0000000000',
user_id: '0000000000',
with_member: true
});
Field |
Type |
Description |
channel_id |
snowflake |
the id of the channel |
user_id |
snowflake |
the id of the user to add |
with_member? |
boolean |
whether to include a guild member object |
after? |
snowflake |
Get thread members after this user ID |
limit? |
integer |
Max number of thread members to return (1-100). Defaults to 100. |
await mapih.discord.channels.threads.getAllMembers({
channel_id: '0000000000',
with_member: true
});
• When called on a GUILD_TEXT
channel, returns threads of type PUBLIC_THREAD
.
• When called on a GUILD_ANNOUNCEMENT
channel, returns threads of type ANNOUNCEMENT_THREAD
.
• Threads are ordered by archive_timestamp
, in descending order.
Field |
Type |
Description |
channel_id |
snowflake |
the id of the channel |
before? |
ISO8601 timestamp |
returns threads archived before this timestamp |
limit? |
integer |
optional maximum number of threads to return |
await mapih.discord.channels.threads.getAllPublicArchived({
channel_id: '0000000000',
limit: 10
});
Field |
Type |
Description |
channel_id |
snowflake |
the id of the channel |
before? |
ISO8601 timestamp |
returns threads archived before this timestamp |
limit? |
integer |
optional maximum number of threads to return |
await mapih.discord.channels.threads.getAllPrivateArchived({
channel_id: '0000000000'
});
Field |
Type |
Description |
channel_id |
snowflake |
the id of the channel |
before? |
ISO8601 timestamp |
returns threads archived before this timestamp |
limit? |
integer |
optional maximum number of threads to return |
await mapih.discord.channels.threads.getAllJoinedPrivateArchived({
channel_id: '0000000000'
});
Method |
Description |
create |
Create a reaction for the message |
createMany |
Create multiple reactions to a message at once |
deleteOwn |
Delete a reaction the current user has made for the message |
deleteUser |
Deletes another user's reaction |
deleteAll |
Deletes all reactions on a message |
deleteAllEmoji |
Deletes all the reactions for a given emoji on a message |
getUsers |
Get a list of users that reacted with this emoji |
| Field | Type | Description |
|------------------------|-------------------------|
| channel_id | snowflake | the id of the channel |
| message_id | snowflake | the id of the message |
| emoji | string | the emoji to react with |
await mapih.discord.channels.reactions.create({
channel_id: '0000000000',
message_id: '0000000000',
emoji: 'name:id'
});
| Field | Type | Description |
|------------------------|--------------------------------------------------------------------------------------------------|
| channel_id | snowflake | The id of the channel |
| message_id | snowflake | The id of the message |
| emojis | string[] | An array of emoji parameters |
| delay? | number | Amount of millseconds to wait between reactions. For use when getting rate-limited. Default 300. |
await mapih.discord.channels.reactions.createMany({
channel_id: '0000000000',
message_id: '0000000000',
emojis: [
'name:id:',
'name:id:',
'name:id:'
],
delay: 200
});
| Field | Type | Description |
|------------------------|-------------------------|
| channel_id | snowflake | the id of the channel |
| message_id | snowflake | the id of the message |
| emoji | string | the emoji to react with |
await mapih.discord.channels.reactions.deleteOwn({
channel_id: '0000000000',
message_id: '0000000000',
emoji: 'name:id'
});
| Field | Type | Description |
|------------------------|-----------------------------------------|
| channel_id | snowflake | the id of the channel |
| message_id | snowflake | the id of the message |
| user_id | snowflake | the id the user the reaction belongs to |
| emoji | string | the emoji to react with |
await mapih.discord.channels.reactions.deleteUser({
channel_id: '0000000000',
message_id: '0000000000',
user_id: '0000000000',
emoji: 'name:id'
});
| Field | Type | Description |
|------------------------|-------------------------|
| channel_id | snowflake | the id of the channel |
| message_id | snowflake | the id of the message |
await mapih.discord.channels.reactions.deleteAll({
channel_id: '0000000000',
message_id: '0000000000'
});
| Field | Type | Description |
|------------------------|-------------------------|
| channel_id | snowflake | the id of the channel |
| message_id | snowflake | the id of the message |
| emoji | string | the emoji to delete |
await mapih.discord.channels.reactions.deleteAllEmoji({
channel_id: '0000000000',
message_id: '0000000000',
emoji: ':name:id'
});
| Field | Type | Description |
|------------------------|----------------------------------------------------|
| channel_id | snowflake | the id of the channel |
| message_id | snowflake | the id of the message |
| emoji | string | the emoji to get users for |
| after? | snowflake | Get users after this user ID |
| limit? | integer | Max number of users to return (1-100) (default 25) |
await mapih.discord.channels.reactions.getUsers({
channel_id: '0000000000',
message_id: '0000000000',
emoji: ':name:id',
limit: 50
});
All functions relating to Discord Users
Field |
Type |
Description |
user_id |
snowflake |
the id of the user |
await mapih.discord.users.retrieve({
user_id: '0000000000'
});
await mapih.discord.users.currentUser();
Field |
Type |
Description |
before |
snowflake |
get guilds before this guild ID |
after |
snowflake |
get guilds after this guild ID |
limit |
integer |
max number of guilds to return (1-200) (default 200) |
with_counts |
boolean |
include approximate member and presence counts in response |
await mapih.discord.users.myGuilds();
Field |
Type |
Description |
guild_id |
snowflake |
id of the guild to get member object from |
await mapih.discord.users.currentMember({
guild_id: '0000000000',
});
All parameters to this endpoint are optional.
Field |
Type |
Description |
username |
string |
user's username |
avatar |
url/buffer |
if passed, modifies the user's avatar |
await mapih.discord.users.updateCurrent({
username: 'new username',
avatar: 'https://imageURL.png'
});
await mapih.discord.users.connections();
Field |
Type |
Description |
application_id? |
snowflake |
bot's application id |
await mapih.discord.users.appRoleConnection();
Requires an OAuth2 access token with role_connections.write
scope for the application specified in the path.
Field |
Type |
Description |
platform_name? |
string |
the vanity name of the platform a bot has connected (max 50 characters) |
platform_username? |
string |
the username on the platform a bot has connected (max 100 characters) |
metadata? |
object |
object mapping application role connection metadata keys to their string -ified value (max 100 characters) for the user on the platform a bot has connected |
await mapih.discord.users.updateAppRoleConnection({
platform_name: 'OnSocket',
platform_username: 'goodsie'
});
Field |
Type |
Description |
recipient_id |
snowflake |
the recipient to open a DM channel with |
content?* |
string |
Message contents (up to 2000 characters) |
tts? |
boolean |
true if this is a TTS message |
embeds?* |
array of embed objects |
Up to 10 rich embeds (up to 6000 characters) |
allowed_mentions? |
allowed mention object |
Allowed mentions for the message |
message_reference? |
message reference |
Include to make your message a reply |
components?* |
array of message component objects |
Components to include with the message |
sticker_ids?* |
array of snowflakes |
IDs of up to 3 stickers in the server to send in the message |
attachments? |
array of partial attachment objects |
Attachment objects with filename and description. |
flags? |
integer |
Message flags (only SUPPRESS_EMBEDS and SUPPRESS_NOTIFICATIONS can be set) |
* At least one of content
, embeds
, sticker_ids
, components
, or files[n]
is required.
await mapih.discord.users.createDM({
recipient_id: '0000000000',
content: '<super cool message here>'
});
Field |
Type |
Description |
access_tokens |
array of strings |
access tokens of users that have granted your app the gdm.join scope |
nicks |
dict |
a dictionary of user ids to their respective nicknames |
content?* |
string |
Message contents (up to 2000 characters) |
tts? |
boolean |
true if this is a TTS message |
embeds?* |
array of embed objects |
Up to 10 rich embeds (up to 6000 characters) |
allowed_mentions? |
allowed mention object |
Allowed mentions for the message |
message_reference? |
message reference |
Include to make your message a reply |
components?* |
array of message component objects |
Components to include with the message |
sticker_ids?* |
array of snowflakes |
IDs of up to 3 stickers in the server to send in the message |
attachments? |
array of partial attachment objects |
Attachment objects with filename and description. |
flags? |
integer |
Message flags (only SUPPRESS_EMBEDS and SUPPRESS_NOTIFICATIONS can be set) |
* At least one of content
, embeds
, sticker_ids
, components
, or files[n]
is required.
await mapih.discord.users.createGroupDM({
access_tokens: [
'0000000000',
'0000000000'
],
nicks: {
'user_id': 'nickname'
},
content: 'boo',
});
Field |
Type |
Description |
guild_id |
snowflake |
the id of the guild to leave |
await mapih.discord.users.leaveGuild({
guild_id: '0000000000'
});
| Namespace |
| Callback |
| Followup |
Method |
Description |
reply |
Create a response to an Interaction |
defer |
Send "thinking" state and edit response later |
get_original |
Get the initial Interaction response |
update_original |
Edit the initial Interaction response |
delete_original |
Delete the initial Interaction response |
component_defer * |
Acknowledge an interaction and edit response later |
component_update * |
Edit the message the component was attached to |
autocomplete_reply |
Respond to an autocomplete interaction with suggested choices |
modal_reply ** |
Respond to an interaction with a popup modal |
upgrade *** |
Respond to an interaction with an upgrade button |
* Only valid for component-based interactions.
** Not available for MODAL_SUBMIT
and PING
interactions.
*** Only available for apps with monetization enabled.
Field |
Type |
Description |
params |
object |
The interaction payload |
ephemeral? |
boolean |
Whether the message should be visible to only the user |
content?* |
string |
Message contents (up to 2000 characters) |
tts? |
boolean |
true if this is a TTS message |
embeds?* |
array of embed objects |
Up to 10 rich embeds (up to 6000 characters) |
allowed_mentions? |
allowed mention object |
Allowed mentions for the message |
components?* |
array of message component objects |
Components to include with the message |
attachments? |
array of partial attachment objects |
Attachment objects with filename and description |
* At least one of content
, embeds
, sticker_ids
, components
, or files[n]
is required.
await mapih.discord.interactions.callback.reply(params, {
ephemeral: true,
content: 'This will respond to an interaction immediately'
});
Defer Interaction Response
Field |
Type |
Description |
params |
object |
The interaction payload |
ephemeral? |
boolean |
Whether the message should be visible to only the user |
await mapih.discord.interactions.callback.defer(params, {
ephemeral: true
});
await mapih.discord.interactions.callback.defer(params)
Field |
Type |
Description |
params |
object |
The interaction payload |
await mapih.discord.interactions.callback.get_original(params);
Field |
Type |
Description |
params |
object |
The interaction payload |
content?* |
string |
Message contents (up to 2000 characters) |
embeds?* |
array of embed objects |
Up to 10 rich embeds (up to 6000 characters) |
allowed_mentions? |
allowed mention object |
Allowed mentions for the message |
components?* |
array of message component objects |
Components to include with the message |
attachments? |
array of partial attachment objects |
Attachment objects with filename and description |
await mapih.discord.interactions.callback.update_original(params, {
content: 'This will update the original interaction response'
});
Field |
Type |
Description |
params |
object |
The interaction payload |
await mapih.discord.interactions.callback.delete_original(params);
Field |
Type |
Description |
params |
object |
The interaction payload |
await mapih.discord.interactions.callback.component_defer(params);
Field |
Type |
Description |
params |
object |
The interaction payload |
content?* |
string |
Message contents (up to 2000 characters) |
embeds?* |
array of embed objects |
Up to 10 rich embeds (up to 6000 characters) |
allowed_mentions? |
allowed mention object |
Allowed mentions for the message |
components?* |
array of message component objects |
Components to include with the message |
attachments? |
array of partial attachment objects |
Attachment objects with filename and description |
await mapih.discord.interactions.callback.component_update(params, {
content: 'new stuff!'
});
Field |
Type |
Description |
params |
object |
The interaction payload |
choices |
array of choices
|
Autocomplete Choices (max of 25 choices) |
await mapih.discord.interactions.callback.autocomplete_reply(params, {
choices: [
{
name: 'this might be wrong',
value: 'let me know'
}
]
});
Field |
Type |
Description |
custom_id |
string |
a developer-defined identifier for the modal, max 100 characters |
title |
string |
the title of the popup modal, max 45 characters |
components |
array of components |
between 1 and 5 (inclusive) components that make up the modal |
await callback.modal_reply(params, {
custom_id: 'modal_id',
title: 'Title goes here',
components: [
{
type: 4,
custom_id: 'id_1',
label: 'this is a label',
style: 1, // short
placeholder: 'this is a placeholder',
required: true
},
{
type: 4,
custom_id: 'id_2',
label: 'This is another label',
style: 1, // paragraph
value: 'this is a pre-filled value',
required: false
}
]
});
Method |
Description |
retrieve |
Get a followupmessage for an interaction |
create |
Create a followup message for an interaction |
update |
Edit a followup message for an interaction |
destroy |
Delete a followup message for an interaction |
Field |
Type |
Description |
params |
object |
The interaction payload |
message_id |
snowflake |
The message id of the message to retrieve |
await mapih.discord.interactions.followup.retrieve(params, {
message_id: '0000000000'
});
Field |
Type |
Description |
params |
object |
The interaction payload |
ephemeral? |
boolean |
Whether the message should be visible to only the user |
content?* |
string |
Message contents (up to 2000 characters) |
embeds?* |
array of embed objects |
Up to 10 rich embeds (up to 6000 characters) |
allowed_mentions? |
allowed mention object |
Allowed mentions for the message |
components?* |
array of message component objects |
Components to include with the message |
attachments? |
array of partial attachment objects |
Attachment objects with filename and description |
* At least one of content
, embeds
, sticker_ids
, components
, or files[n]
is required.
await mapih.discord.interactions.followup.create(params, {
ephemeral: true,
content: 'followup message',
embeds: [{
title: 'hello',
description: 'this is a description'
}]
});
Field |
Type |
Description |
params |
object |
The interaction payload |
message_id |
snowflake |
The id of the message to update |
content?* |
string |
Message contents (up to 2000 characters) |
embeds?* |
array of embed objects |
Up to 10 rich embeds (up to 6000 characters) |
allowed_mentions? |
allowed mention object |
Allowed mentions for the message |
components?* |
array of message component objects |
Components to include with the message |
attachments? |
array of partial attachment objects |
Attachment objects with filename and description |
* At least one of content
, embeds
, sticker_ids
, components
, or files[n]
is required.
await mapih.discord.interactions.followup.update(params, {
message_id: '0000000000',
content: 'followup message',
embeds: [{
title: 'hello',
description: 'this is a description'
}]
});
Field |
Type |
Description |
params |
object |
The interaction payload |
message_id |
snowflake |
The message id of the message to retrieve |
await mapih.discord.interactions.followup.destroy(params, {
message_id: '0000000000'
});
All functions relating to Discord Webhooks
Field |
Type |
Description |
webhook_id |
snowflake |
the id of the webhook |
await mapih.discord.webhooks.retrieve({
webhook_id: '0000000000'
});
This call does not require authentication and returns no user in the webhook object.
Field |
Type |
Description |
webhook_id |
snowflake |
the id of the webhook |
webhook_token |
string |
the webhook's token |
await mapih.discord.webhooks.retrieveWithToken({
webhook_id: '0000000000',
webhook_token: 'abcdef123456'
});
Field |
Type |
Description |
channel_id |
snowflake |
the id of the channel |
await mapih.discord.webhooks.retrieveChannel({
webhook_id: '0000000000'
});
Field |
Type |
Description |
guild_id |
snowflake |
the id of the guild |
await mapih.discord.webhooks.retrieveGuild({
guild_id: '0000000000'
});
Field |
Type |
Description |
webhook_id |
snowflake |
the id of the webhook |
webhook_token |
snowflake |
the webhook's token |
message_id |
snowflake |
the id of the message |
thread_id |
snowflake |
id of the thread the message is in |
await mapih.discord.webhooks.retrieveMessage({
webhook_id: '0000000000',
webhook_token: 'abcdef123456',
message_id: '0000000000'
});
Field |
Type |
Description |
webhook_id |
snowflake |
the id of the webhook |
webhook_token |
snowflake |
the webhook's token |
message_id |
snowflake |
the id of the message |
thread_id |
snowflake |
id of the thread the message is in |
content? |
string |
Message contents (up to 2000 characters) |
embeds? |
array of embed objects |
Up to 10 rich embeds (up to 6000 characters) |
allowed_mentions? |
allowed mention object |
Allowed mentions for the message |
components? |
array of message component objects |
Components to include with the message |
attachments? |
array of partial attachment objects |
Attachment objects with filename and description |
await mapih.discord.webhooks.updateMessage({
webhook_id: '0000000000',
webhook_token: 'abcdef123456',
message_id: '0000000000',
content: 'hello'
});
Field |
Type |
Description |
webhook_id |
snowflake |
the id of the webhook |
webhook_token |
snowflake |
the webhook's token |
message_id |
snowflake |
the id of the message |
thread_id |
snowflake |
id of the thread the message is in |
await mapih.discord.webhooks.destroyMessage({
webhook_id: '0000000000',
webhook_token: 'abcdef123456',
message_id: '0000000000'
});
Field |
Type |
Description |
channel_id? |
snowflake |
the channel id of the channel to create webhook for |
name? |
string |
name of the webhook (1-80 characters) |
avatar? |
?url/buffer |
image for the default webhook avatar |
await mapih.discord.webhooks.create({
channel_id: '0000000000',
name: 'myNewWebhook'
});
Field |
Type |
Description |
webhook_id |
snowflake |
the webhook id of the webhook to edit |
channel_id |
snowflake |
the channel id of the channel to create webhook for |
name |
string |
name of the webhook (1-80 characters) |
avatar? |
?url/buffer |
image for the default webhook avatar |
await mapih.discord.webhooks.update({
webhook_id: '0000000000',
channel_id: '0000000000',
name: 'myNewNewWebhook'
});
Field |
Type |
Description |
webhook_id |
snowflake |
the webhook id of the webhook to edit |
webhook_token |
string |
the token of the webhook to edit |
name? |
string |
name of the webhook (1-80 characters) |
avatar? |
?url/buffer |
image for the default webhook avatar |
await mapih.discord.webhooks.updateWithToken({
webhook_id: '0000000000',
webhook_token: 'abcd1234',
name: 'myNewNewWebhook'
});
Field |
Type |
Description |
webhook_id |
snowflake |
the id of the webhook |
await mapih.discord.webhooks.destroy({
webhook_id: '0000000000'
});
Field |
Type |
Description |
webhook_id |
snowflake |
the id of the webhook |
webhook_token |
string |
the webhook's token |
await mapih.discord.webhooks.destroyWithToken({
webhook_id: '0000000000',
webhook_token: 'abcdef123456'
});
Field |
Type |
Description |
webhook_id |
snowflake |
the id of the webhook |
webhook_token |
snowflake |
the webhook's token |
username |
string |
override the default username of the webhook |
avatar_url |
string |
override the default avatar of the webhook |
thread_id |
snowflake |
id of the thread the message is in |
content |
string |
Message contents (up to 2000 characters) |
embeds |
array of embed objects |
Up to 10 rich embeds (up to 6000 characters) |
allowed_mentions |
allowed mention object |
Allowed mentions for the message |
components |
array of message component objects |
Components to include with the message |
attachments |
array of partial attachment objects |
Attachment objects with filename and description |
thread_name |
string |
name of thread to create (requires the webhook channel to be a forum or media channel) |
applied_tags |
array of snowflakes |
array of tag ids to apply to the thread (requires the webhook channel to be a forum or media channel) |
wait |
boolean |
Waits for server confirmation of message send before response, and returns the created message body |
await mapih.discord.webhooks.execute({
webhook_id: '0000000000',
webhook_token: 'abcdef123456',
content: 'message contents here',
username: 'webhook usernrame',
avatar_url: 'https://imgurl.png',
embeds: [{
title: 'example',
description: 'example'
}]
});
All functions relating to Discord Invites
Method |
Description |
retrieve |
Get information about a specific invite |
revoke |
Revoke an invite |
Field |
Type |
Description |
invite_code |
string |
the invite's code |
with_counts? |
boolean |
whether the invite should contain approximate member counts |
with_expiration? |
boolean |
whether the invite should contain the expiration date |
guild_scheduled_event_id? |
snowflake |
the guild scheduled event to include with the invite |
await mapih.discord.invites.retrieve({
invite_code: '0vCdhLbwjZZTWZLD',
with_counts: true,
with_expiration: true
});
| Field | Type | Description |
| invite_code | string | the invite's code |
await mapih.discord.invites.revoke({
invite_code: '0vCdhLbwjZZTWZLD'
});
All Discord API endpoints relating to applications, commands, entitlements and SKUs
Method |
Description |
getMe |
Get inforation on the current application |
updateMe |
Edit properties of the app associated with the requesting bot user |
appRoleConnectionMeta |
Get the applications role connection metadata information |
updateAppRoleConnectionMeta |
Updates the application role connection metadata for the given application |
Field |
Type |
Description |
application_id? |
snowflake |
the id of the application |
await mapih.discord.applications.getMe();
Field |
Type |
Description |
application_id? |
snowflake |
the id of the application |
custom_install_url |
string |
Default custom authorization URL for the app, if enabled |
description |
string |
Description of the app |
role_connections_verification_url |
string |
Role connection verification URL for the app |
install_params |
install params object |
Settings for the app's default in-app authorization link, if enabled |
flags * |
number |
App's public flags
|
icon |
url/buffer |
Icon for the app |
cover_image |
url/buffer |
Default rich presence invite cover image for the app |
interactions_endpoint_url ** |
string |
Interactions endpoint URL for the app |
tags |
array of strings |
List of tags describing the content and functionality of the app (max of 20 characters per tag). Max of 5 tags. |
* Only limited intent flags (GATEWAY_PRESENCE_LIMITED
, GATEWAY_GUILD_MEMBERS_LIMITED
, and GATEWAY_MESSAGE_CONTENT_LIMITED
) can be updated via the mapih.
await mapih.discord.applications.updateMe({
description: 'new description',
icon: 'https://url_to_image.png' // or buffer,
install_params: {
scopes: [
'identify',
'bot',
'applications.commands'
],
permissions: '8'
}
});
Field |
Type |
Description |
application_id? |
snowflake |
the id of the application |
await mapih.discord.applications.appRoleConnectionMeta();
Field |
Type |
Description |
application_id? |
snowflake |
the id of the application |
await mapih.discord.applications.updateAppRoleConnectionMeta();
This is to be used for both global and guild commands.
Provide a guild_id field if using for a guild command.
Field |
Type |
Description |
command_id |
snowflake |
the id of the command |
application_id? |
snowflake |
the id of the application |
guild_id? |
snowflake |
the id of the guild |
await mapih.discord.applications.commands.retrieve({
command_id: '0000000000',
guild_id: '0000000000'
})
This is to be used for both global and guild commands.
Provide a guild_id field if using for a guild command.
Field |
Type |
Description |
application_id? |
snowflake |
the id of the application |
guild_id? |
snowflake |
the id of the guild |
with_localizations? |
boolean |
Whether to include full localization dictionaries (name_localizations and description_localizations ) in the returned objects, instead of the name_localized and description_localized fields. |
await mapih.discord.applications.commands.getAll();
await mapih.discord.applications.commands.getAll({
guild_id: '0000000000'
})
This is to be used for both global and guild commands.
Provide a guild_id field if using for a guild command.
Field |
Type |
Description |
application_id? |
snowflake |
the id of the application |
guild_id? |
snowflake |
the id of the guild |
name |
string |
Name of command, 1-32 characters |
name_localizations? |
?dictionary with keys in available locales |
Localization dictionary for the name field. Values follow the same restrictions as name
|
description? |
string |
1-100 character description for CHAT_INPUT commands |
description_localizations? |
?dictionary with keys in available locales |
Localization dictionary for the description field. Values follow the same restrictions as description
|
options? |
array of application command option
|
the parameters for the command |
default_member_permissions? |
?string |
Set of permissions represented as a bit set |
dm_permission? |
?boolean |
Indicates whether the command is available in DMs with the app, only for globally-scoped commands. By default, commands are visible. |
type? |
one of application command type
|
Type of command, defaults 1 if not set |
nsfw? |
boolean |
Indicates whether the command is age-restricted |
await mapih.discord.applications.commands.create({
name: 'slashcommand',
description: 'Command description',
guild_id: '0000000000', // optional
options: [{
type: 1, // SUB_COMMAND
name: 'subCommand',
options: [
{
type: 3, // STRING
name: 'content',
description: 'Enter content here',
required: true
},
{
type: 6, // USER
name: 'user',
description: 'Select a user'
}
]
}]
})
This is to be used for both global and guild commands.
Provide a guild_id field if using for a guild command.
Field |
Type |
Description |
application_id? |
snowflake |
the id of the application |
guild_id? |
snowflake |
the id of the guild |
name |
string |
Name of command, 1-32 characters |
name_localizations? |
?dictionary with keys in available locales |
Localization dictionary for the name field. Values follow the same restrictions as name
|
description? |
string |
1-100 character description for CHAT_INPUT commands |
description_localizations? |
?dictionary with keys in available locales |
Localization dictionary for the description field. Values follow the same restrictions as description
|
options? |
array of application command option
|
the parameters for the command |
default_member_permissions? |
?string |
Set of permissions represented as a bit set |
dm_permission? |
?boolean |
Indicates whether the command is available in DMs with the app, only for globally-scoped commands. By default, commands are visible. |
nsfw? |
boolean |
Indicates whether the command is age-restricted |
await mapih.discord.applications.commands.update({
name: 'slashcommand',
description: 'Command description',
guild_id: '0000000000', // optional
options: [{
type: 1, // SUB_COMMAND
name: 'subCommand',
options: [
{
type: 3, // STRING
name: 'content',
description: 'Enter content here',
required: true
},
{
type: 6, // USER
name: 'user',
description: 'Select a user'
}
]
}]
})
This is to be used for both global and guild commands.
Provide a guild_id field if using for a guild command.
Field |
Type |
Description |
command_id |
snowflake |
the id of the command |
application_id? |
snowflake |
the id of the application |
guild_id? |
snowflake |
the id of the guild |
await mapih.discord.applications.commands.destroy({
command_id: '0000000000',
guild_id: '0000000000'
})
This is to be used for both global and guild commands.
Provide a guild_id field if using for a guild command.
• Takes a list of application commands, overwriting the existing global command list for this application.
Field |
Type |
Description |
application_id? |
snowflake |
the id of the application |
guild_id? |
snowflake |
the id of the guild |
commands |
array of application commands
|
Commands to overwrite the existing commands with |
await mapih.discord.applications.commands.bulkOverwrite({
command_id: '0000000000',
guild_id: '0000000000',
commands: [commands]
})
• Fetches permissions for a specific command for your application in a guild.
Field |
Type |
Description |
command_id |
snowflake |
the id of the command |
application_id? |
snowflake |
the id of the application |
guild_id |
snowflake |
the id of the guild |
await mapih.discord.applications.commands.retrievePermissions({
command_id: '0000000000',
guild_id: '0000000000'
})
• Fetches permissions for all commands for your application in a guild.
Field |
Type |
Description |
application_id? |
snowflake |
the id of the application |
guild_id |
snowflake |
the id of the guild |
await mapih.discord.applications.commands.getAllPermissions({
guild_id: '0000000000'
})
• Edits command permissions for a specific command for your application in a guild.
Field |
Type |
Description |
application_id? |
snowflake |
the id of the application |
guild_id |
snowflake |
the id of the guild |
permissions |
array of application command permissions
|
Permissions for the command in the guild |
await mapih.discord.applications.commands.updatePermissions({
guild_id: '0000000000',
permissions: [{
id: '0000000000',
type: 2,
'true'
}]
})
Method |
Description |
getAll |
Get all entitlements for a given app |
create |
Creates a test entitlement to a given SKU for a given guild or user |
destroy |
Deletes a currently-active test entitlement |
• Returns all entitlements for a given app, active and expired.
Field |
Type |
Description |
application_id? |
snowflake |
the id of the application |
user_id? |
snowflake |
User ID to look up entitlements for |
sku_ids? |
comma-delimited set of snowflakes |
Optional list of SKU IDs to check entitlements for |
before? |
snowflake |
Retrieve entitlements before this entitlement ID |
after? |
snowflake |
Retrieve entitlements after this entitlement ID |
limit? |
number |
Number of entitlements to return, 1-100, default 100 |
guild_id? |
snowflake |
Guild ID to look up entitlements for |
exclude_ended? |
boolean |
Whether or not ended entitlements should be omitted |
await mapih.discord.applications.entitlements.retrieve({
user_id: '0000000000',
before: '0000000000',
after: '0000000000',
limit: 2
})
• Creates a test entitlement to a given SKU for a given guild or user. Discord will act as though that user or guild has entitlement to your premium offering.
• This endpoint returns a partial entitlement object. It will not contain subscription_id
, starts_at
, or ends_at
, as it's valid in perpetuity.
• After creating a test entitlement, you'll need to reload your Discord client. After doing so, you'll see that your server or user now has premium access.
Field |
Type |
Description |
application_id? |
snowflake |
the id of the application |
sku_id |
string |
ID of the SKU to grant the entitlement to |
owner_id |
string |
ID of the guild or user to grant the entitlement to |
owner_type |
number |
1 for a guild subscription, 2 for a user subscription |
await mapih.discord.applications.entitlements.create({
sku_id: '0000000000',
owner_id: '0000000000',
owner_type: 1
})
• Deletes a currently-active test entitlement. Discord will act as though that user or guild no longer has entitlement to your premium offering.
Field |
Type |
Description |
application_id? |
snowflake |
the id of the application |
await mapih.discord.applications.entitlements.delete()
Method |
Description |
getAll |
Get all SKUs for a given application |
• Because of how our SKU and subscription systems work, you will see two SKUs for your premium offering. For integration and testing entitlements, you should use the SKU with type: 5
.
Field |
Type |
Description |
application_id? |
snowflake |
the id of the application |
await mapih.discord.applications.SKUs.getAll();
Method |
Description |
retrieve |
Get the audit logs for the guild |
The returned list of audit log entries is ordered based on whether you use before
or after
.
When using before
, the list is ordered by the audit log entry ID descending (newer entries first).
If after
is used, the list is reversed and appears in ascending order (older entries first).
Omitting both before
and after
defaults to before
the current timestamp and will show the most recent entries in descending order by ID, the opposite can be achieved using after=0
(showing oldest entries).
Field |
Type |
Description |
guild_id |
snowflake |
the id of the application |
user_id? |
snowflake |
Entries from a specific user ID |
action_type? |
number |
Entries for a specific audit log event
|
before? |
snowflake |
Entries with ID less than a specific audit log entry ID |
after? |
snowflake |
Entries with ID greater than a specific audit log entry ID |
limit? |
number |
Maximum number of entries (between 1-100) to return, defaults to 50 |
await mapih.discord.auditlog.retrieve({
guild_id: '0000000000',
user_id: '0000000000',
limit: 10 // default 50
});
Field |
Type |
Description |
guild_id |
snowflake |
the id of the guild |
auto_moderation_rule_id |
snowflake |
the id of the automod rule |
await mapih.discord.automod.retrieveRule({
auto_moderation_rule_id: '0000000000',
guild_id: '0000000000'
})
Field |
Type |
Description |
guild_id |
snowflake |
the id of the guild |
await mapih.discord.automod.getAll({
guild_id: '0000000000'
})
Field |
Type |
Description |
guild_id |
snowflake |
the id of the guild |
name |
string |
the rule name |
event_type |
integer |
the event type
|
trigger_type |
integer |
the trigger type
|
trigger_metadata? * |
object |
the trigger metadata
|
actions |
array of action objects |
the actions which will execute when the rule is triggered |
enabled? |
boolean |
whether the rule is enabled (False by default) |
exempt_roles? |
array of snowflakes |
the role ids that should not be affected by the rule (Max 20) |
exempt_channels? |
array of snowflakes |
the channel ids that should not be affected by the rule (Max 50) |
await mapih.discord.automod.createRule({
guild_id: '0000000000',
name: 'EricsAutoModRule',
event_type: 1 // MESSAGE_SEND
trigger_type: 3 // SPAM
actions: [{
type: 2, // SEND_ALERT_MESSAGE
metadata: { channel_id: '0000000000' }
}],
enabled: true,
exempt_roles: ['0000000000'],
exempt_channels: ['0000000000']
})
Field |
Type |
Description |
guild_id |
snowflake |
the id of the guild |
name |
string |
the rule name |
event_type |
integer |
the event type
|
trigger_metadata? * |
object |
the trigger metadata
|
actions |
array of action objects |
the actions which will execute when the rule is triggered |
enabled? |
boolean |
whether the rule is enabled (False by default) |
exempt_roles? |
array of snowflakes |
the role ids that should not be affected by the rule (Max 20) |
exempt_channels? |
array of snowflakes |
the channel ids that should not be affected by the rule (Max 50) |
await mapih.discord.automod.updateRule({
guild_id: '0000000000',
auto_moderation_rule_id: '00000',
name: 'EricsAutoModRule',
event_type: 1 // MESSAGE_SEND
actions: [{
type: 1, // BLOCK_MESSAGE
metadata: { custom_message: 'GO AWAY' }
}],
trigger_metadata: {
keyword_filter: ['cat*', '*dog'],
regex_patterns: ['^(?:[0-9]{1,3}\\.){3}[0-9]{1,3}$']
},
enabled: true
})
Field |
Type |
Description |
guild_id |
snowflake |
the id of the guild |
auto_moderation_rule_id |
snowflake |
the id of the automod rule |
await mapih.discord.automod.destroyRule({
auto_moderation_rule_id: '0000000000',
guild_id: '0000000000'
})
A Stage Instance holds information about a live stage.
Method |
Description |
retrieve |
Gets the stage instance associated with the Stage channel |
create |
Creates a new Stage instance associated to a Stage channel |
update |
Updates fields of an existing Stage instance |
destroy |
Deletes the Stage instance |
Field |
Type |
Description |
channel_id |
snowflake |
the id of the channel that the stage instance is in |
await mapih.discord.stageInstance.retrieve({
channel_id: '0000000000'
});
Field |
Type |
Description |
channel_id |
snowflake |
The id of the Stage channel |
topic |
string |
The topic of the Stage instance (1-120 characters) |
privacy_level? |
integer |
The privacy level of the Stage instance (default GUILD_ONLY) |
send_start_notification? * |
boolean |
Notify @everyone that a Stage instance has started |
guild_scheduled_event_id? |
snowflake |
The guild scheduled event associated with this Stage instance |
* The stage moderator must have the MENTION_EVERYONE
permission for this notification to be sent.
await mapih.discord.stageInstance.create({
channel_id: '0000000000',
topic: 'My super cool stage',
send_start_notification: true
});
Field |
Type |
Description |
channel_id |
snowflake |
The id of the Stage channel |
topic? |
string |
The topic of the Stage instance (1-120 characters) |
privacy_level? |
integer |
The privacy level of the Stage instance (default GUILD_ONLY) |
await mapih.discord.stageInstance.update({
channel_id: '0000000000',
topic: 'My super duper cool stage',
});
Field |
Type |
Description |
channel_id |
snowflake |
the id of the channel that the stage instance is in |
await mapih.discord.stageInstance.destroy({
channel_id: '0000000000'
});
Method |
Description |
create |
Creat a chat completion |
Field |
Type |
Description |
model |
string |
ID of the model to use |
messages |
ChatCompletionMessage[] |
A list of messages comprising the conversation so far |
max_tokens? |
number |
The maximum number of tokens that can be generated in the chat completion |
temperature? |
number |
What sampling temperature to use, between 0 and 2. Higher values like 0.8 will make the output more random, while lower values like 0.2 will make it more focused and deterministic. |
top_p? |
number |
An alternative to sampling with temperature, called nucleus sampling, where the model considers the results of the tokens with top_p probability mass. So 0.1 means only the tokens comprising the top 10% probability mass are considered. |
frequency_penalty? |
number |
Number between -2.0 and 2.0. Positive values penalize new tokens based on their existing frequency in the text so far, decreasing the model's likelihood to repeat the same line verbatim. |
presence_penalty? |
number |
Number between -2.0 and 2.0. Positive values penalize new tokens based on whether they appear in the text so far, increasing the model's likelihood to talk about new topics. |
n? |
number |
How many chat completion choices to generate for each input message |
response_format? |
string |
An object specifying the format that the model must output. Setting to { "type": "json_object" } enables JSON mode, which guarantees the message the model generates is valid JSON. |
seed? |
number |
This feature is in Beta. If specified, our system will make a best effort to sample deterministically, such that repeated requests with the same seed and parameters should return the same result. |
stop? |
string |
Up to 4 sequences where the API will stop generating further tokens |
logit_bias? |
Object |
Modify the likelihood of specified tokens appearing in the completion. Accepts a JSON object that maps tokens (specified by their token ID in the tokenizer) to an associated bias value from -100 to 100. |
logprobs? |
boolean |
Whether to return log probabilities of the output tokens or not |
top_logprobs? |
number |
An integer between 0 and 5 specifying the number of most likely tokens to return at each token position, each with an associated log probability |
stream? |
boolean |
If set, partial message deltas will be sent, like in ChatGPT. |
tools? |
ToolCalls[] |
A list of tools the model may call. Currently, only functions are supported as a tool. Use this to provide a list of functions the model may generate JSON inputs for. |
tool_choice? |
ToolChoice |
Controls which (if any) function is called by the model. See tool_choice
|
user? |
string |
A unique identifier representing your end-user, which can help OpenAI to monitor and detect abuse |
await mapih.openai.chat.create({
model: 'gpt-4',
messages: [
{
role: 'system',
content: 'You are a chatbot'
},
{
role: 'user',
content: 'hello!'
}
],
max_tokens: 1024,
temperature: 0.7
});
Many of the Spotify endpoints are designed for the input of a specific Spotify ID.
However, I have also incorporated the functionality to accept names.
Each endpoint includes options for both the ID* and the name**.
Utilizing a specific ID ensures the retrieval of the correct item.
On the other hand, providing a name might result in incorrect items depending on the uniqueness of the name.
* song_id(s)
, artist_id(s)
, album_id(s)
, playlist_id(s)
** song_name(s)
, artist_name(s)
, album_name(s)
, playlist_name(s)
Method |
Description |
me |
Get detailed profile information about the current user |
topItems |
Get the current user's top artists or tracks |
getProfile |
Get public profile information about a Spotify user |
await mapih.spotify.users.me();
Field |
Type |
Description |
type |
string |
The type of entity to return (artists or tracks ) |
time_range? * |
string |
Over what time frame the affinities are computed (default medium_term ) |
limit? |
number |
The maximum number of results to return |
offset? |
number |
The index of the first result to return. Use with limit to get the next page of search results. |
* Valid values for time_range
:
-
long_term
: calculated from several years of data and including all new data as it becomes available
-
medium_term
: approximately last 6 months
-
short_term
: approximately last 4 weeks
await mapih.spotify.users.topItems({
type: 'tracks',
time_range: 'long_term',
limit: 10
});
Field |
Type |
Description |
user_id |
string |
The user's Spotify user ID |
await mapih.spotify.users.getProfile({
user_id: 'smedjan'
});
Method |
Description |
advanced |
Extensive search for songs, artists, albums |
artists |
Search for artists |
songs |
Search for songs |
albums |
Search for albums |
Field |
Type |
Description |
song? * |
string |
Song name to search for |
artist? * |
string |
Artist name to search for |
album? * |
string |
Album name to search for |
include? |
string[] |
Type of results to include. One or more of songs , artists , albums . |
limit? |
number |
The maximum number of results to return |
offset? |
number |
The index of the first result to return. Use with limit to get the next page of search results. |
sort? |
string |
Sort results by: popularity , followers , or duration_seconds
|
year? |
string |
Filter on a single year or a range (e.g. 1955-1960) |
genre? |
string |
Filter on a single genre |
* At least one of song
, artist
, album
is required.
await mapih.spotify.search.advanced({
song: 'oops i did it again',
year: '1990-1995',
limit: 1
});
await mapih.spotify.search.advanced({
song: 'some popular song name',
limit: 10,
sort: 'popularity'
});
await mapih.spotify.search.advanced({
album: 'your favorite album name',
include: ['albums'],
});
Field |
Type |
Description |
artist |
string |
Artist name to |