Skip to main content
The Game SDK has been archived.We recommend using the Discord Social SDK for new projects.Existing projects using the Game SDK will continue to work, but we encourage you to migrate to the Discord Social SDK for new features and updates.
Welcome to the documentation for the Discord Game SDK! We’re glad you made it. The Game SDK helps you develop your 3rd party game or app, and integrate it with Discord.

​
Getting Started

This section will walk you through the first few steps you need to take to get up-and-running with the Game SDK. After you download the SDK and configure your app, you can find more details in the Using the SDK section.

​
Step 1: Get the SDK

Now, let’s get started. First, get the SDK. Here it is: There’s a few things in there, but let’s quickly talk about what the SDK actually is. Inside the lib/ folder, you’ll see x86/ and x86_64/ that have some .lib, .bundle, and .dll files. These are the things you want to distribute with your game. These files are comprised of two parts: a “stub”, and fallback modules. What that means is that when everything is running smoothly, the DLLs will just call back to the local running Discord client to do the heavy lifting. If, however, something is wrong, like a breaking change, the files also include “fallback” modules that reflect the native SDK modules in Discord at the time that version of the SDK was published. TLDR - you don’t need to worry about breaking changes.

​
Step 2: Create your App

Next, we need to set up the application for your game. An app is the base “entity” in Discord for your game. Head over to our developer site and create an account/log in if you haven’t yet. The first thing we’re going to do is create a Team. Teams are groups of developers working together on applications; you should create a team for your organization at https://discord.com/developers/teams. You can invite other users to join your team and work on applications together with you. Now that your team is created, you’ll want to make an application. To do so, click on “Applications” at the top of the page and create an application. Make sure you pick your newly-created team in the Team dropdown. You want your team to own the application! Now that your app is made, let’s dive into some more setup.
If you’re integrating our SDK into an already-released game, there’s a good chance that we may already have an application in our database for your game! Reach out to our Dev Support to learn more
First, we’ll need to set an OAuth2 redirect URL. You can add http://127.0.0.1 in there for now; this powers some behind-the-scenes stuff you don’t need to worry about. Next, copy the Client ID at the top of the page. This id, also referred to as an “application id”, is your game’s unique identifier across Discord. Keep it handy! While you’re here, head to the “OAuth2” section of your application and add http://127.0.0.1 as a redirect URI for your application. This will allow us to do the OAuth2 token exchange within the Discord client.

​
Step 3: Start Coding

Before you start developing, there are a couple of notes to keep in mind about the SDK:
  • All strings in the SDK are UTF8 strings. Make sure you’ve converted properly if necessary!
  • The SDK is NOT threadsafe!
With that out of the way, let’s start coding. Didn’t think we’d get there so fast, did ya? Think again! The dropdowns are code primers for the main languages of the SDK: C#, C, and C++. They’ll get you up and running with the most basic examples, and then you’re off to the races.
  • Open up that SDK zip that you downloaded.
  • Copy the contents of the lib/ folder to Assets/Plugins in your Unity project
  • Copy the contents of the csharp/ folder to Assets/Plugins/DiscordGame SDK
From there, you’ll be able to reference functions in the DLL within your scripts. A basic example of a script can be found in this example repo. In this example, we attach our DiscordController.cs script to the Main Camera object of the default created scene. We then instantiate the SDK with:
/*
    Grab that Client ID from earlier
    Discord.CreateFlags.Default will require Discord to be running for the game to work
    If Discord is not running, it will:
    1. Close your game
    2. Open Discord
    3. Attempt to re-open your game
    Step 3 will fail when running directly from the Unity editor
    Therefore, always keep Discord running during tests, or use Discord.CreateFlags.NoRequireDiscord
*/
var discord = new Discord.Discord(CLIENT_ID, (UInt64)Discord.CreateFlags.Default);
You’re now free to use other functionality in the SDK! Make sure to call discord.RunCallbacks() in your main game loop; that’s your Update() function.You’re ready to go! Check out the rest of the documentation for more info on how to use the other pieces of the SDK. See an example of everything it can do in examples/Program.cs in the SDK zip file.
  • Open up that SDK zip that you downloaded.
  • Create a folder in your project directory called DiscordGame SDK and copy the contents of the csharp/ folder to it
  • Build your solution then place the .dll in the directory of the .exe (either x86 or x86_64 version depending on your compile platform). If you compile for Any CPU you may need to perform additional wrapping around DLL importing (like setting the DLL directory dynamically) to make sure you load the correct DLL.
From there, you’ll be able to reference functions in the DLL within your scripts. We then instantiate the SDK with:
/*
    Grab that Client ID from earlier
    Discord.CreateFlags.Default will require Discord to be running for the game to work
    If Discord is not running, it will:
    1. Close your game
    2. Open Discord
    3. Attempt to re-open your game
    Step 3 may fail when running directly from your editor
    Therefore, always keep Discord running during tests, or use Discord.CreateFlags.NoRequireDiscord
*/
var discord = new Discord.Discord(CLIENT_ID, (UInt64)Discord.CreateFlags.Default);
You’re now free to use other functionality in the SDK! Make sure to call discord.RunCallbacks() in your main game loop; that’s your Update() function.You’re ready to go! Check out the rest of the documentation for more info on how to use the other pieces of the SDK. See an example of everything it can do in examples/Program.cs in the SDK zip file.
Before jumping into the C binding, a word of caution. If you are using Unreal Engine 3, or need to support an older version of Visual Studio, you may at first see some unexpected crashes due to compile configurations. The way to fix this is to wrap the include statement for the Discord Game SDK header file like so:
#pragma pack(push, 8)
#include "discord_game_sdk.h"
#pragma pack(pop)
This should let you use the SDK without any further crashes. Now, on with the show!
  • Open up that SDK zip that you downloaded.
  • Copy the contents of the lib/ folder to the best location within your project for DLLs.
  • Copy the contents of the c/ folder to your source directory
  • It’s dangerous to go alone—take this small code block with you (to start)!
struct Application {
    struct IDiscordCore* core;
    struct IDiscordUsers* users;
};

struct Application app;
// Don't forget to memset or otherwise initialize your classes!
memset(&app, 0, sizeof(app));

struct IDiscordCoreEvents events;
memset(&events, 0, sizeof(events));

struct DiscordCreateParams params;
params.client_id = CLIENT_ID;
params.flags = DiscordCreateFlags_Default;
params.events = &events;
params.event_data = &app;

DiscordCreate(DISCORD_VERSION, &params, &app.core);
  • Make sure to call core->run_callbacks(core, 0) in your game loop.
You’re ready to go! Check out the rest of the documentation for more info on how to use the other pieces of the SDK. See an example of everything it can do in examples/c/main.c in the SDK zip file.
First, you’ll want to copy the header files and .cpp files to a folder somewhere in your project directory. For ease of a quickstart example, you can put them right inside your Source/your-project-name folder; I’d put them in a containing folder called something like discord-files/.Second, you’ll want to copy the .dll and .lib files from the lib/x86_64 folder of the downloaded zip. These files should be put in your-project-name/Binaries/Win64/. For win32, take the files from x86/ and put them, in your-project-name/Binaries/Win32.Next, we need to link these files within our project so that we can reference them. If you open up your project’s .sln file in Visual Studio, you’ll find a file called your-project-name.Build.cs. We’re going to add the following lines of code to that file:
/*
    ABSOLUTE_PATH_TO_DISCORD_FILES_DIRECTORY will look something like:

    "H:\\Unreal Projects\\Game SDKtest\\Source\\Game SDKtest\\discord-files\\"

    You should get this value programmatically
*/
PublicIncludePaths.Add(ABSOLUTE_PATH_TO_DISCORD_FILES_DIRECTORY)

/*
    ABSOLUTE_PATH_TO_LIB_FILE will look something like:

    "H:\\Unreal Projects\\Game SDKtest\\Binaries\\Win64\\discord_game_sdk.dll.lib"

    You should get this value programmatically
*/
PublicAdditionalLibraries.Add(ABSOLUTE_PATH_TO_LIB_FILE)
Now that we’ve got our new dependencies properly linked, we can reference them in our code. In this example, we’re going to make a new Pawn class called MyPawn. It will look something like this:
#include "MyPawn.h"
#include "discord-files/discord.h"

discord::Core* core{};

AMyPawn::AMyPawn()
{
  // Set this pawn to call Tick() every frame.  You can turn this off to improve performance if you don't need it.
  PrimaryActorTick.bCanEverTick = true;
}

// Called when the game starts or when spawned
void AMyPawn::BeginPlay()
{
  Super::BeginPlay();
  /*
      Grab that Client ID from earlier
      Discord.CreateFlags.Default will require Discord to be running for the game to work
      If Discord is not running, it will:
      1. Close your game
      2. Open Discord
      3. Attempt to re-open your game
      Step 3 will fail when running directly from the Unreal Engine editor
      Therefore, always keep Discord running during tests, or use Discord.CreateFlags.NoRequireDiscord
  */
  auto result = discord::Core::Create(461618159171141643, DiscordCreateFlags_Default, &core);
  discord::Activity activity{};
  activity.SetState("Testing");
  activity.SetDetails("Fruit Loops");
  core->ActivityManager().UpdateActivity(activity, [](discord::Result result) {

  });
}

// Called every frame
void AMyPawn::Tick(float DeltaTime)
{
  Super::Tick(DeltaTime);
  ::core->RunCallbacks();
}

// Called to bind functionality to input
void AMyPawn::SetupPlayerInputComponent(UInputComponent* PlayerInputComponent)
{
  Super::SetupPlayerInputComponent(PlayerInputComponent);
}
Make sure you’ve got core->RunCallbacks() going every frame!You’re ready to go! Check out the rest of the documentation for more info on how to use the other pieces of the SDK. See an example of everything it can do in examples/cpp/main.cpp in the SDK zip file.
In your project folder, you’ll want to make something like a “discord-files” folder, for organization. In that folder, copy all the .h and .cpp files from the zip. You want to include all the header and source files respectively in your projectCorrect FilesIn your project settings, you’ll want to include the relevant library (e.g. discord_game_sdk.dll.lib) as an additional dependency.Linked Library
  • From there, you should be able to #include "discord-files/discord.h", or whatever the path to that header file is, and have access to the code.

​
Using the SDK

At a high level, the Discord Game SDK has a parent class, Discord. This class is in charge of the creation of a few “manager” sub-classes to interact with Discord.

​
Managers

Each manager class contains its own functions and events used to interact with Discord in the context of the manager:
NameDescription
ActivityManagerfor Rich Presence and game invites
OverlayManagerfor interacting with Discord’s built-in overlay
UserManagerfor fetching user data for a given id and the current user

​
Using Functions in the SDK

Most functions in the Discord Game SDK, uh, function in a similar way. They take whatever parameters are required for the function to do its job—a user id, the requested size for an image, etc.—and a callback by means of a function pointer. That callback is fired when the function completes its work, letting you handle events without worrying about piping asynchronously-returned data to the right context. Some functions behave with a normal return behavior; e.g. RelationshipManager.Count() just returns the number directly. Don’t worry, it’s outlined in the docs. 
var userManager = discord.GetUserManager();

// Return via callback
userManager.GetUser(290926444748734465, (Discord.Result result, ref Discord.User otherUser) =>
{
  if (result == Discord.Result.Ok)
  {
    Console.WriteLine(otherUser.Username);
    Console.WriteLine(otherUser.Id);
  }
});


// Return normally
userManager.OnCurrentUserUpdate += () =>
{
    var currentUser = userManager.GetCurrentUser();
        Console.WriteLine(currentUser.Username);
        Console.WriteLine(currentUser.Discriminator);
        Console.WriteLine(currentUser.Id);
};

​
Environment Variables

Discord passes a number of environment variables down to the SDK. These are accessed by various functions in the SDK and can be changed for local testing by changing the value in your local environment.
namemethoddescription
DISCORD_INSTANCE_IDLocal Testingthe locally running instance of Discord to connect to; allows you to choose between multiple running clients
DISCORD_ACCESS_TOKENApplicationManager.GetOAuth2Token()the connected user’s bearer token
DISCORD_CURRENT_LOCALEApplicationManager.GetCurrentLocale()the language that Discord is in for the connected user
DISCORD_CURRENT_BRANCHApplicationManager.GetCurrentBranch()the branch of the running application that the user has launched

​
Error Handling

Debugging is a pain, so before we get into the meat of the SDK, we want to make sure you’re prepared for when things go awry. Within the Discord core is a function called SetLogHook(). It takes a level, which is minimum level of log message you want to listen to, and a callback function: 
public void LogProblemsFunction(Discord.LogLevel level, string message)
{
  Console.WriteLine("Discord:{0} - {1}", level, message);
}

discord.SetLogHook(Discord.LogLevel.Debug, LogProblemsFunction);
You should begin your integration by setting up this callback to help you debug. Helpfully, if you put a breakpoint inside the callback function you register here, you’ll be able to see the stack trace for errors you run into (as long as they fail synchronously). Take the guess work out of debugging, or hey, ignore any and all logging by setting a callback that does nothing. We’re not here to judge.

​
Testing Locally

While integrating the Discord Game SDK, you will probably find yourself wanting to test functionality between two game clients locally, be it for networking, Rich Presence, etc. We know that getting a test build of a game on two separate machines can be both difficult and cumbersome. So, we’ve got a solution for you!
Value from environment variable DISCORD_INSTANCE_ID
By using system environment variables, you can tell the SDK in a certain game client to connect to a specific Discord client. Here’s how it works:
  1. Download Discord Canary. This is our most updated build, and is good to develop against: Windows - Mac
  2. Download a second Discord Build. Here’s our Public Test Build: Windows - Mac
  3. Open up two Discord clients. We recommend you develop against Discord Canary, so you can use PTB or Stable for your test account
  4. Log in with two separate users. Make sure any test account is added to the application’s App Whitelist in the portal!
Now, in your game code, you can tell the SDK which client to connect to via the environment variable DISCORD_INSTANCE_ID before initializing the SDK. The value of the variable corresponds to the order in which you opened the clients, so 0 would connect to the first opened client, 1 the second, etc.
Environment Variable Example
// This machine opened Discord Canary first, and Discord PTB second

// This makes the SDK connect to Canary
System.Environment.SetEnvironmentVariable("DISCORD_INSTANCE_ID", "0");
var discord = new Discord(applicationId, Discord.CreateFlags.Default);

// This makes the SDK connect to PTB
System.Environment.SetEnvironmentVariable("DISCORD_INSTANCE_ID", "1");
var discord = new Discord(applicationId, Discord.CreateFlags.Default);
This will set the environment variable only within the context of the running process, so don’t worry about messing up global stuff.
If you test with this, make sure to remove this code before pushing a production build. It will interfere with the way that Discord launches games for users.

​
Data Models

​
Result Enum

Codevaluedescription
0Okeverything is good
1ServiceUnavailableDiscord isn’t working
2InvalidVersionthe SDK version may be outdated
3LockFailedan internal error on transactional operations
4InternalErrorsomething on our side went wrong
5InvalidPayloadthe data you sent didn’t match what we expect
6InvalidCommandthat’s not a thing you can do
7InvalidPermissionsyou aren’t authorized to do that
8NotFetchedcouldn’t fetch what you wanted
9NotFoundwhat you’re looking for doesn’t exist
10Conflictuser already has a network connection open on that channel
11InvalidSecretactivity secrets must be unique and not match party id
12InvalidJoinSecretjoin request for that user does not exist
13NoEligibleActivityyou accidentally set an ApplicationId in your UpdateActivity() payload
14InvalidInviteyour game invite is no longer valid
15NotAuthenticatedthe internal auth call failed for the user, and you can’t do this
16InvalidAccessTokenthe user’s bearer token is invalid
17ApplicationMismatchaccess token belongs to another application
18InvalidDataUrlsomething internally went wrong fetching image data
19InvalidBase64not valid Base64 data
20NotFilteredyou’re trying to access the list before creating a stable list with Filter()
21LobbyFullthe lobby is full
22InvalidLobbySecretthe secret you’re using to connect is wrong
23InvalidFilenamefile name is too long
24InvalidFileSizefile is too large
25InvalidEntitlementthe user does not have the right entitlement for this game
26NotInstalledDiscord is not installed
27NotRunningDiscord is not running
28InsufficientBufferinsufficient buffer space when trying to write
29PurchaseCancelleduser cancelled the purchase flow
30InvalidGuildDiscord guild does not exist
31InvalidEventthe event you’re trying to subscribe to does not exist
32InvalidChannelDiscord channel does not exist
33InvalidOriginthe origin header on the socket does not match what you’ve registered (you should not see this)
34RateLimitedyou are calling that method too quickly
35OAuth2Errorthe OAuth2 process failed at some point
36SelectChannelTimeoutthe user took too long selecting a channel for an invite
37GetGuildTimeouttook too long trying to fetch the guild
38SelectVoiceForceRequiredpush to talk is required for this channel
39CaptureShortcutAlreadyListeningthat push to talk shortcut is already registered
40UnauthorizedForAchievementyour application cannot update this achievement
41InvalidGiftCodethe gift code is not valid
42PurchaseErrorsomething went wrong during the purchase flow
43TransactionAbortedpurchase flow aborted because the SDK is being torn down

​
LogLevel Enum

valuedescription
ErrorLog only errors
WarningLog warnings and errors
InfoLog info, warnings, and errors
DebugLog all the things!

​
CreateFlags Enum

valuedescription
DefaultRequires Discord to be running to play the game
NoRequireDiscordDoes not require Discord to be running, use this on other platforms

​
Functions

​
Create

Creates an instance of Discord to initialize the SDK. This is the overlord of all things Discord. We like to call her Nelly. Returns a new Discord.
Parameters
nametypedescription
clientIdInt64your application’s client id
flagsCreateFlagsthe creation parameters for the SDK, outlined above
Example
// c++ land
discord::Core* core{};
discord::Core::Create(53908232506183680, DiscordCreateFlags_Default, &core);

// c# land
var discord = new Discord(53908232506183680, (UInt64)Discord.CreateFlags.Default);

​
Destroy

Destroys the instance. Wave goodbye, Nelly! You monster. In C# land, this is Dispose().
The C++ binding does not include a destroy() method, as the destructor for the Core does the work for you.
Returns void.
Example
discord.Dispose();

​
SetLogHook

Registers a logging callback function with the minimum level of message to receive. The callback function should have a signature of: 
MyCallbackFunction(LogLevel level, string message);
Returns void.
Parameters
nametypedescription
levelLogLevelthe minimum level of event to log
callbackfunctionthe callback function to catch the messages
Example
public void LogProblemsFunction(Discord.LogLevel level, string message)
{
  Console.WriteLine("Discord:{0} - {1}", level, message);
}

discord.SetLogHook(Discord.LogLevel.Debug, LogProblemFunctions);

​
RunCallbacks

Runs all pending SDK callbacks. Put this in your game’s main event loop, like Update() in Unity. That way, the first thing your game does is check for any new info from Discord. This function also serves as a way to know that the local Discord client is still connected. If the user closes Discord while playing your game, RunCallbacks() will return/throw Discord.Result.NotRunning. In C and C++, this function returns Discord.Result. In C#, it returns void and will throw Discord.Result error if something went wrong.
Example
void Update()
{
  discord.RunCallbacks();
}

​
GetActivityManager

Fetches an instance of the manager for interfacing with activities in the SDK. Returns an ActivityManager.
Example
var activityManager = discord.GetActivityManager();

​
GetUserManager

Fetches an instance of the manager for interfacing with users in the SDK. Returns an UserManager.
Example
var userManager = discord.GetUserManager();

​
GetOverlayManager

Fetches an instance of the manager for interfacing with the overlay in the SDK. Returns an OverlayManager.
Example
var overlayManager = discord.GetOverlayManager();

​
Activities

Looking to build a game inside of Discord? Check out the (other) Activities and the Embedded SDK documentation.
Looking to integrate Rich Presence into your game? No need to manage multiple SDKs—this one does all that awesome stuff, too! Delight your players with the ability to post game invites in chat and party up directly from Discord. Surface interesting live game data in their profile for their friends, encouraging them to group up and play together. For more detailed information and documentation around the Rich Presence feature set and integration tips, check out our Rich Presence Documentation.

​
Data Models

​
User Struct

nametypedescription
idInt64the user’s id
usernamestringtheir name
discriminatorstringthe user’s unique discrim
avatarstringthe hash of the user’s avatar
botboolif the user is a bot user

​
Activity Struct

nametypedescription
applicationIdInt64your application id - this is a read-only field
namestringname of the application - this is a read-only field
statestringthe player’s current party status
details??stringwhat the player is currently doing
timestamps??ActivityTimestampshelps create elapsed/remaining timestamps on a player’s profile
assets??ActivityAssetsassets to display on the player’s profile
party??ActivityPartyinformation about the player’s party
secrets??ActivitySecretssecret passwords for joining and spectating the player’s game
instance??boolwhether this activity is an instanced context, like a match

​
ActivityTimestamps Struct

nametypedescription
start??Int64unix timestamp - send this to have an “elapsed” timer
end??Int64unix timestamp - send this to have a “remaining” timer

​
ActivityAssets Struct

nametypedescription
largeImage??stringsee Activity Asset Image
largeText??stringhover text for the large image
smallImage??stringsee Activity Asset Image
smallText??stringhover text for the small image

​
ActivityParty Struct

nametypedescription
idstringa unique identifier for this party
sizePartySizeinfo about the size of the party

​
PartySize Struct

nametypedescription
currentSizeInt32the current size of the party
maxSizeInt32the max possible size of the party

​
ActivitySecrets Struct

nametypedescription
match??stringunique hash for the given match context
join??stringunique hash for chat invites and Ask to Join
spectate??stringunique hash for Spectate button

​
ActivityType Enum

nameValue
Playing0
Streaming1
Listening2
Watching3
Custom4
Competing5
For more details about the activity types, see Gateway documentation. ActivityType is strictly for the purpose of handling events that you receive from Discord; though the SDK will not reject a payload with an ActivityType sent, it will be discarded and will not change anything in the client.

​
ActivityJoinRequestReply Enum

namevalue
No0
Yes1
Ignore2

​
ActivityActionType Enum

namevalue
Join1
Spectate2

​
Activity Action Field Requirements

If you want to hook up joining and spectating for your games, there are certain fields in the activity payload that need to be sent. Refer to the following handy table for what needs to be set for certain actions.
FieldCustom ArtworkSpectateJoinAsk to Join
State
Details
ActivityTimestamps.start
ActivityTimestamps.end
ActivityAssets.largeImagex
ActivityAssets.smallImagex
ActivityAssets.largeTextx
ActivityAssets.smallTextx
ActivityParty.idxx
ActivityParty.size.currentSizexx
ActivityParty.size.maxSizexx
ActivitySecrets.joinxx
ActivitySecrets.spectatex

​
Functions

​
RegisterCommand

Registers a command by which Discord can launch your game. This might be a custom protocol, like my-awesome-game://, or a path to an executable. It also supports any launch parameters that may be needed, like game.exe --full-screen --no-hax. On macOS, due to the way Discord registers executables, your game needs to be bundled for this command to work. That means it should be a .app. Returns void.
Parameters
nametypedescription
commandstringthe command to register
Example
activityManager.RegisterCommand("my-awesome-game://run --full-screen");

​
RegisterSteam

Used if you are distributing this SDK on Steam. Registers your game’s Steam app id for the protocol steam://run-game-id/<id>. Returns void.
Parameters
nametypedescription
steamIdUInt32your game’s Steam app id
Example
activityManager.RegisterSteam(1938123);

​
UpdateActivity

Sets a user’s presence in Discord to a new activity. This has a rate limit of 5 updates per 20 seconds.
It is possible for users to hide their presence on Discord (User Settings -> Game Activity). Presence set through this SDK may not be visible when this setting is toggled off.
Returns a Discord.Result via callback.
Parameters
nametypedescription
activityActivitythe new activity for the user
Example
var activity = new Discord.Activity
{
  State = "In Play Mode",
  Details = "Playing the Trumpet!",
  Timestamps =
  {
      Start = 5,
  },
  Assets =
  {
      LargeImage = "foo largeImageKey", // Larger Image Asset Value
      LargeText = "foo largeImageText", // Large Image Tooltip
      SmallImage = "foo smallImageKey", // Small Image Asset Value
      SmallText = "foo smallImageText", // Small Image Tooltip
  },
  Party =
  {
      Id = "foo partyID",
      Size = {
          CurrentSize = 1,
          MaxSize = 4,
      },
  },
  Secrets =
  {
      Match = "foo matchSecret",
      Join = "foo joinSecret",
      Spectate = "foo spectateSecret",
  },
  Instance = true,
};

activityManager.UpdateActivity(activity, (result) =>
{
    if (result == Discord.Result.Ok)
    {
        Console.WriteLine("Success!");
    }
    else
    {
        Console.WriteLine("Failed");
    }
});

​
ClearActivity

Clear’s a user’s presence in Discord to make it show nothing. Results a Discord.Result via callback.
Example
activityManager.ClearActivity((result) =>
{
    if (result == Discord.Result.Ok)
    {
        Console.WriteLine("Success!");
    }
    else
    {
        Console.WriteLine("Failed");
    }
});

​
SendRequestReply

Sends a reply to an Ask to Join request. Returns a Discord.Result via callback.
Parameters
nametypedescription
userIdInt64the user id of the person who asked to join
replyActivityJoinRequestReplyNo, Yes, or Ignore
Example
activityManager.OnActivityJoinRequest += user =>
{
    Console.WriteLine("Join request from: {0}", user.Id);
    activityManager.SendRequestReply(user.Id, Discord.ActivityJoinRequestReply.Yes, (res) =>
    {
      if (res == Discord.Result.Ok)
      {
        Console.WriteLine("Responded successfully");
      }
    });
}

​
SendInvite

Sends a game invite to a given user. If you do not have a valid activity with all the required fields, this call will error. See Activity Action Field Requirements for the fields required to have join and spectate invites function properly. Returns a Discord.Result via callback.
Parameters
nametypedescription
userIdInt64the id of the user to invite
typeActivityActionTypemarks the invite as an invitation to join or spectate
contentstringa message to send along with the invite
Example
var userId = 53908232506183680;
activityManager.SendInvite(userId, Discord.ActivityActionType.Join, "Come play!", (result) =>
{
    if (result == Discord.Result.Ok)
    {
        Console.WriteLine("Success!");
    }
    else
    {
        Console.WriteLine("Failed");
    }
});

​
AcceptInvite

Accepts a game invitation from a given userId. Returns a Discord.Result via callback.
Parameters
nametypedescription
userIdInt64the id of the user who invited you
Example
activityManager.AcceptInvite(290926444748734466, (result) =>
{
    if (result == Discord.Result.Ok)
    {
        Console.WriteLine("Success!");
    }
    else
    {
        Console.WriteLine("Failed");
    }
});

​
Events

​
OnActivityJoin

Fires when a user accepts a game chat invite or receives confirmation from Asking to Join.
Parameters
nametypedescription
joinSecretstringthe secret to join the user’s game
Example
// Received when someone accepts a request to join or invite.
// Use secrets to receive back the information needed to add the user to the group/party/match
activityManager.OnActivityJoin += secret => {
    Console.WriteLine("OnJoin {0}", secret);
    // Now update your internal systems to reflect the user as joined

		// Sends this off to a Activity callback named here as 'UpdateActivity' passing in the discord instance details
    UpdateActivity(discord);
};

void UpdateActivity(Discord.Discord discord)
    {
    	//Creates a Static String for Spectate Secret.
        string discordSpectateSecret = "wdn3kvj320r8vk3";
        spectateActivitySecret = discordSpectateSecret;
        var activity = new Discord.Activity
        {
            State = "Playing Co-Op",
            Details = "In a Multiplayer Match!",
            Timestamps =
            {
                Start = startTimeStamp,
            },
            Assets =
            {
                LargeImage = "matchimage1",
                LargeText = "Inside the Arena!",
            },
            Party = {
                Id = <Party/match/group id here>,
                Size = {
                    CurrentSize = ...,
                    MaxSize = ...,
                },
            },
            Secrets = {
                Spectate = spectateActivitySecret,
                Join = joinActivitySecret,
            },
            Instance = true,
        };

        activityManager.UpdateActivity(activity, result =>
        {
            Debug.LogFormat("Updated to Multiplayer Activity: {0}", result);

            // Send an invite to another user for this activity.
            // Receiver should see an invite in their DM.
            // Use a relationship user's ID for this.
            // activityManager
            //   .SendInvite(
            //       364843917537050624,
            //       Discord.ActivityActionType.Join,
            //       "",
            //       inviteResult =>
            //       {
            //           Console.WriteLine("Invite {0}", inviteResult);
            //       }
            //   );
        });
    }

​
OnActivitySpectate

Fires when a user accepts a spectate chat invite or clicks the Spectate button on a user’s profile.
Parameters
nametypedescription
spectateSecretstringthe secret to join the user’s game as a spectator
Example
// Received when someone accepts a request to spectate
activityManager.OnActivitySpectate += secret =>
{
    Console.WriteLine("OnSpectate {0}", secret);
};

​
OnActivityJoinRequest

Fires when a user asks to join the current user’s game.
Parameters
nametypedescription
userUserthe user asking to join
Example
// A join request has been received. Render the request on the UI.
activityManager.OnActivityJoinRequest += (ref Discord.User user) =>
{
    Console.WriteLine("OnJoinRequest {0} {1}", user.Username, user.Id);
};

​
OnActivityInvite

Fires when the user receives a join or spectate invite.
Parameters
nametypedescription
typeActivityActiontypewhether this invite is to join or spectate
userUserthe user sending the invite
activityActivitythe inviting user’s current activity
Example
// An invite has been received. Consider rendering the user / activity on the UI.
activityManager.OnActivityInvite += (Discord.ActivityActionType Type, ref Discord.User user, ref Discord.Activity activity2) =>
{
      Console.WriteLine("Received Invite Type: {0}, from User: {1}, with Activity Name: {2}", Type, user.Username, activity2.Name);
      // activityManager.AcceptInvite(user.Id, result =>
      // {
      //     Console.WriteLine("AcceptInvite {0}", result);
      // });
};

​
Inviting a User to a Game

var discord = new Discord.Discord(clientId, Discord.CreateFlags.Default);

// Update user's activity for your game.
// Party and secrets are vital.
var activity = new Discord.Activity
{
  State = "olleh",
  Details = "foo details",
  Timestamps =
  {
      Start = 5,
      End = 6,
  },
  Assets =
  {
      LargeImage = "foo largeImageKey",
      LargeText = "foo largeImageText",
      SmallImage = "foo smallImageKey",
      SmallText = "foo smallImageText",
  },
  Party =
  {
      Id = "foo partyID",
      Size = {
          CurrentSize = 1,
          MaxSize = 4,
      },
  },
  Secrets =
  {
      Match = "foo matchSecret",
      Join = "foo joinSecret",
      Spectate = "foo spectateSecret",
  },
  Instance = true,
};

activityManager.UpdateActivity(activity, (result) =>
{
    Console.WriteLine("Update Activity {0}", result);

    // Send an invite to another user for this activity.
    // Receiver should see an invite in their DM.
    // Use a relationship user's ID for this.
    activityManager.SendInvite(364843917537050999, Discord.ActivityActionType.Join, "", (inviteUserResult) =>
    {
        Console.WriteLine("Invite User {0}", inviteUserResult);
    });
});

​
Overlay

The overlay is only supported on Windows for DirectX or OpenGL games. Linux, Mac, and games using Vulkan are not supported. Click here for more info.
Discord comes with an awesome built-in overlay, and you may want to make use of it for your game. This manager will help you do just that! It gives you the current state of the overlay for the user, and allows you to update that state.

​
Data Models

​
ActivityActionType Enum

namevalue
Join1
Spectate2

​
Functions

​
IsEnabled

Check whether the user has the overlay enabled or disabled. If the overlay is disabled, all the functionality in this manager will still work. The calls will instead focus the Discord client and show the modal there instead. Returns a bool.
Example
if (!overlaymanager.IsEnabled())
{
  Console.WriteLine("Overlay is not enabled. Modals will be shown in the Discord client instead");
}

​
IsLocked

Check if the overlay is currently locked or unlocked
Example
if (overlayManager.IsLocked())
{
  overlayManager.SetLocked(true, (res) =>
  {
    Console.WriteLine("Input in the overlay is now accessible again");
  });
}

​
SetLocked

Locks or unlocks input in the overlay. Calling SetLocked(true); will also close any modals in the overlay or in-app from things like IAP purchase flows and disallow input. Returns Discord.Result via callback.
Parameters
nametypedescription
lockedboollock or unlock the overlay
Example
overlayManager.SetLocked(true, (res) =>
{
  Console.WriteLine("Overlay has been locked and modals have been closed");
});

​
OpenActivityInvite

Opens the overlay modal for sending game invitations to users, channels, and servers. If you do not have a valid activity with all the required fields, this call will error. See Activity Action Field Requirements for the fields required to have join and spectate invites function properly. Returns a Discord.Result via callback.
Parameters
nametypedescription
typeActivityActionTypewhat type of invite to send
Example
overlayManager.OpenActivityInvite(Discord.ActivityActionType.Join, (result) =>
{
  if (result == Discord.Result.Ok)
  {
    Console.WriteLine("User is now inviting others to play!");
  }
});

​
OpenGuildInvite

Opens the overlay modal for joining a Discord guild, given its invite code. An invite code for a server may look something like fortnite for a verified server—the full invite being discord.gg/fortnite—or something like rjEeUJq for a non-verified server, the full invite being discord.gg/rjEeUJq. Returns a Discord.Result via callback. Note that a successful Discord.Result response does not necessarily mean that the user has joined the guild. If you want more granular control over and knowledge about users joining your guild, you may want to look into implementing the guilds.join OAuth2 scope in an authorization code grant in conjunction with the Add Guild Members endpoint.
Parameters
nametypedescription
codestringan invite code for a guild
Example
overlayManager.OpenGuildInvite("rjEeUJq", (result) =>
{
  if (result == Discord.Result.Ok)
  {
    Console.WriteLine("Invite was valid.");
  }
});

​
OpenVoiceSettings

Opens the overlay widget for voice settings for the currently connected application. These settings are unique to each user within the context of your application. That means that a user can have different favorite voice settings for each of their games!
Screenshot of the Voice Settings modal for an application
Returns a Discord.Result via callback.
Example
overlayManager.OpenVoiceSettings((result) =>
{
  if (result == Discord.Result.Ok)
  {
    Console.WriteLine("Overlay is open to the voice settings for your application/")
  }
})

​
OnToggle

Fires when the overlay is locked or unlocked (a.k.a. opened or closed)
Parameters
nametypedescription
lockedboolis the overlay now locked or unlocked
Example
overlayManager.OnToggle += overlayLock =>
{
    Console.WriteLine("Overlay Locked: {0}", overlayLock);
};

​
Activate Overlay Invite Modal

var discord = new Discord.Discord(clientId, Discord.CreateFlags.Default);
var overlayManager = discord.GetOverlayManager();

// Invite users to join your game
overlayManager.OpenActivityInvite(ActivityActionType.Join, (result) =>
{
  Console.WriteLine("Overlay is now open!");
})
And that invite modal looks like this!Screenshot of an Invitation Modal in an application

​
Users

This manager helps retrieve basic user information for any user on Discord.

​
Data Models

​
User Struct

nametypedescription
IdInt64the user’s id
Usernamestringtheir name
Discriminatorstringthe user’s unique discrim
Avatarstringthe hash of the user’s avatar
Botboolif the user is a bot user

​
UserFlag Enum

namevaluedescription
Partner2Discord Partner
HypeSquadEvents4HypeSquad Events participant
HypeSquadHouse164House Bravery
HypeSquadHouse2128House Brilliance
HypeSquadHouse3256House Balance

​
PremiumType Enum

namevaluedescription
None0Not a Nitro subscriber
Tier11Nitro Classic subscriber
Tier22Nitro subscriber
Tier33Nitro Basic subscriber

​
Functions

​
GetCurrentUser

Before calling this function, you’ll need to wait for the OnCurrentUserUpdate callback to fire after instantiating the User manager.
Fetch information about the currently connected user account. If you’re interested in getting more detailed information about a user—for example, their email—check out our GetCurrentUser API endpoint. You’ll want to call this with an authorization header of Bearer <token>, where <token> is the token retrieved from a standard OAuth2 Authorization Code Grant flow. Returns a Discord.User.
Example
var user = userManager.GetCurrentUser();
Console.WriteLine("Connected to user {0}", user.Id);

​
GetUser

Get user information for a given id. Returns a Discord.Result and ref Discord.User via callback.
Parameters
nametypedescription
userIdInt64the id of the user to fetch
Example
userManager.GetUser(userId, (Discord.Result result, ref Discord.User user) =>
{
  if (result == Discord.Result.Ok)
  {
    Console.WriteLine("User {0} is {1}", user.Id, user.Username);
  }
});

​
GetCurrentUserPremiumType

Get the PremiumType for the currently connected user. Returns Discord.PremiumType.
Example
var userManager = discord.GetUserManager();
var premiumType = userManager.GetCurrentUserPremiumType();
switch (premiumType)
{
  case PremiumType.None:
    Console.WriteLine("User is not a Nitro subscriber");

  case PremiumType.Tier1:
    Console.WriteLine("User has Nitro Classic");

  case PremiumType.Tier2:
    Console.WriteLine("User has Nitro");

  default:
    return;
}

​
CurrentUserHasFlag

See whether or not the current user has a certain UserFlag on their account. Returns bool.
Parameters
nametypedescription
flagUserFlagthe flag to check on the user’s account
Example
var userManager = discord.GetUserManager();
if (userManager.CurrentUserHasFlag(Discord.UserFlag.HypeSquadHouse1))
{
  Console.WriteLine("User is a member of House Bravery!");
}

​
Events

​
OnCurrentUserUpdate

Fires when the User struct of the currently connected user changes. They may have changed their avatar, username, or something else.
Example
var userManager = discord.GetUserManager();
// GetCurrentUser will error until this fires once.
userManager.OnCurrentUserUpdate += () => {
  var currentUser = userManager.GetCurrentUser();

  Console.WriteLine(currentUser.Username);
  Console.WriteLine(currentUser.Id);
  Console.WriteLine(currentUser.Discriminator);
  Console.WriteLine(currentUser.Avatar);
};

​
Fetching Data About a Discord User

var discord = new Discord.Discord(clientId, Discord.CreateFlags.Default);

var userManager = discord.GetUserManager();
userManager.GetUser(450795363658366976, (Discord.Result result, ref Discord.User user) =>
{
  if (result == Discord.Result.Ok)
  {
    Console.WriteLine("user fetched: {0}", user.Username);
  }
  else
  {
    Console.WriteLine("user fetch error: {0}", result);
  }
});