Discord OAuth2

1. Home
2. Discord OAuth2 /

---

Note

Need help setting it up? Check out this guide!

Add a Application

Adds a new Bot to the database for the OAuth2 Flow

POST /api/discord/oauth2/add

https://api.cookie-api.com/api/discord/oauth2/add

Authentication Learn how to get your API Key and use it in your requests!

Body

{
    "client_id": "Your OAuth2 client ID",
    "client_secret": "Your OAuth2 client secret"
}

cURL

curl --location 'https://api.cookie-api.com/api/discord/oauth2/add' \
--header 'Authorization: API_Key' \
--header 'Content-Type: application/json' \
--data '{"client_secret": "CLIENT_SECRET", "client_id": "1234567890"}'

Python

import requests

url = 'https://api.cookie-api.com/api/discord/oauth2/add'
headers = {
    'Authorization': 'API_Key',
    'Content-Type': 'application/json'
}

data = {
    'client_secret': 'CLIENT_SECRET',
    'client_id': '1234567890'
}

response = requests.post(url, headers=headers, json=data)
print(response.json())

JavaScript

const fetch = require('node-fetch');

const url = 'https://api.cookie-api.com/api/discord/oauth2/add';
const headers = {
    'Authorization': 'API_Key',
    'Content-Type': 'application/json'
};

const data = {
    client_secret: 'CLIENT_SECRET',
    client_id: '1234567890'
};

fetch(url, {
    method: 'POST',
    headers,
    body: JSON.stringify(data)
})
.then(res => res.json())
.then(data => console.log(data))
.catch(err => console.error(err));

Go

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "log"
    "net/http"
)

func main() {
    url := "https://api.cookie-api.com/api/discord/oauth2/add"
    data := map[string]interface{}{
        "client_secret": "CLIENT_SECRET",
        "client_id":     "1234567890",
    }

    jsonData, err := json.Marshal(data)
    if err != nil {
        log.Fatal(err)
    }

    req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
    if err != nil {
        log.Fatal(err)
    }

    req.Header.Set("Authorization", "API_Key")
    req.Header.Set("Content-Type", "application/json")

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        log.Fatal(err)
    }
    defer resp.Body.Close()

    fmt.Println("Response Status:", resp.Status)
}

Node.js

const https = require('https');

const data = JSON.stringify({
    client_secret: 'CLIENT_SECRET',
    client_id: '1234567890'
});

const options = {
    hostname: 'api.cookie-api.com',
    path: '/api/discord/oauth2/add',
    method: 'POST',
    headers: {
        'Authorization': 'API_Key',
        'Content-Type': 'application/json',
        'Content-Length': Buffer.byteLength(data)
    }
};

const req = https.request(options, res => {
    let responseData = '';
    res.on('data', chunk => {
        responseData += chunk;
    });
    res.on('end', () => {
        console.log(JSON.parse(responseData));
    });
});

req.on('error', error => {
    console.error(error);
});

req.write(data);
req.end();

Ruby

require 'net/http'
require 'json'
require 'uri'

uri = URI.parse('https://api.cookie-api.com/api/discord/oauth2/add')

request = Net::HTTP::Post.new(uri)
request['Authorization'] = 'API_Key'
request['Content-Type'] = 'application/json'
request.body = {
    'client_secret' => 'CLIENT_SECRET',
    'client_id' => '1234567890'
}.to_json

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

puts JSON.parse(response.body)

Rust

use reqwest::blocking::Client;
use reqwest::header::HeaderMap;
use serde::{Deserialize, Serialize};

#[derive(Serialize)]
struct Oauth2Request {
    client_secret: String,
    client_id: String,
}

fn main() {
    let url = "https://api.cookie-api.com/api/discord/oauth2/add";
    let client = Client::new();
    let mut headers = HeaderMap::new();
    headers.insert("Authorization", "API_Key".parse().unwrap());

    let request_body = Oauth2Request {
        client_secret: "CLIENT_SECRET".to_string(),
        client_id: "1234567890".to_string(),
    };

    let res = client
        .post(url)
        .headers(headers)
        .json(&request_body)
        .send()
        .unwrap();

    println!("{}", res.text().unwrap());
}

Responses

200

{
    "example_authorization_url": "https://discord.com/api/oauth2/authorize?client_id=1234567890&redirect_uri=https://www.cookie-api.com/api/public/discord/callback/abcdefg&response_type=code&scope=identify",
    "message": "Don't forget to set the redirect url in the Discord Dev Portal :D",
    "redirect_url": "https://www.cookie-api.com/api/public/discord/callback/abcdefg",
    "success": true
}

---

List all Applications

Lists all Applications registered to your account.

GET /api/discord/oauth2/applications/list

https://api.cookie-api.com/api/discord/oauth2/applications/list

Authentication Learn how to get your API Key and use it in your requests!

cURL

curl --location 'https://api.cookie-api.com/api/discord/oauth2/applications/list' \
--header 'Authorization: API_Key'

Python

import requests

url = 'https://api.cookie-api.com/api/discord/oauth2/applications/list'
headers = {
    'Authorization': 'API_Key'
}

response = requests.get(url, headers=headers)
print(response.json())

JavaScript

const fetch = require('node-fetch');

const url = 'https://api.cookie-api.com/api/discord/oauth2/applications/list';
const headers = {
    'Authorization': 'API_Key'
};

fetch(url, {
    method: 'GET',
    headers
})
.then(res => res.json())
.then(data => console.log(data))
.catch(err => console.error(err));

Go

package main

import (
    "fmt"
    "log"
    "net/http"
)

func main() {
    url := "https://api.cookie-api.com/api/discord/oauth2/applications/list"
    req, err := http.NewRequest("GET", url, nil)
    if err != nil {
        log.Fatal(err)
    }

    req.Header.Set("Authorization", "API_Key")

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        log.Fatal(err)
    }
    defer resp.Body.Close()

    fmt.Println("Response Status:", resp.Status)
}

Node.js

const https = require('https');

const options = {
    hostname: 'api.cookie-api.com',
    path: '/api/discord/oauth2/applications/list',
    method: 'GET',
    headers: {
        'Authorization': 'API_Key'
    }
};

const req = https.request(options, res => {
    let responseData = '';
    res.on('data', chunk => {
        responseData += chunk;
    });
    res.on('end', () => {
        console.log(JSON.parse(responseData));
    });
});

req.on('error', error => {
    console.error(error);
});

req.end();

Ruby

require 'net/http'
require 'uri'

uri = URI.parse('https://api.cookie-api.com/api/discord/oauth2/applications/list')

request = Net::HTTP::Get.new(uri)
request['Authorization'] = 'API_Key'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

puts response.body

Rust

use reqwest::blocking::Client;
use reqwest::header::HeaderMap;

fn main() {
    let url = "https://api.cookie-api.com/api/discord/oauth2/applications/list";
    let client = Client::new();

    let mut headers = HeaderMap::new();
    headers.insert("Authorization", "API_Key".parse().unwrap());

    let res = client
        .get(url)
        .headers(headers)
        .send()
        .unwrap();

    println!("{}", res.text().unwrap());
}

Responses

200

{
    "data": [
        {
            "client_id": "1234567890",
            "redirect_uri": "https://api.cookie-api.com/api/public/discord/callback/abcdefg"
        }
    ],
    "results": 1,
    "success": true
}

---

Delete an Application

Deletes an Application from your account.

DELETE /api/discord/oauth2/applications/delete

https://api.cookie-api.com/api/discord/oauth2/applications/delete

Authentication Learn how to get your API Key and use it in your requests!

URL Parameters
client_id	Client ID of the Application to be deleted

cURL

curl --location --request DELETE 'https://api.cookie-api.com/api/discord/oauth2/applications/delete?client_id=1234567890' \
--header 'Authorization: API_Key'

Python

import requests

url = 'https://api.cookie-api.com/api/discord/oauth2/applications/delete'
headers = {
    'Authorization': 'API_Key'
}
params = {
    'client_id': '1234567890'
}

response = requests.delete(url, headers=headers, params=params)
print(response.json())

JavaScript

const fetch = require('node-fetch');

const url = 'https://api.cookie-api.com/api/discord/oauth2/applications/delete?client_id=1234567890';
const headers = {
    'Authorization': 'API_Key'
};

fetch(url, {
    method: 'DELETE',
    headers
})
.then(res => res.json())
.then(data => console.log(data))
.catch(err => console.error(err));

Go

package main

import (
    "fmt"
    "log"
    "net/http"
    "net/url"
)

func main() {
    baseURL := "https://api.cookie-api.com/api/discord/oauth2/applications/delete"
    clientID := "1234567890"
    urlParams := url.Values{}
    urlParams.Add("client_id", clientID)
    urlWithParams := fmt.Sprintf("%s?%s", baseURL, urlParams.Encode())

    req, err := http.NewRequest("DELETE", urlWithParams, nil)
    if err != nil {
        log.Fatal(err)
    }

    req.Header.Set("Authorization", "API_Key")

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        log.Fatal(err)
    }
    defer resp.Body.Close()

    fmt.Println("Response Status:", resp.Status)
}

Node.js

const https = require('https');

const options = {
    hostname: 'api.cookie-api.com',
    path: '/api/discord/oauth2/applications/delete?client_id=1234567890',
    method: 'DELETE',
    headers: {
        'Authorization': 'API_Key'
    }
};

const req = https.request(options, res => {
    let responseData = '';
    res.on('data', chunk => {
        responseData += chunk;
    });
    res.on('end', () => {
        console.log(JSON.parse(responseData));
    });
});

req.on('error', error => {
    console.error(error);
});

req.end();

Ruby

require 'net/http'
require 'uri'
require 'json'

uri = URI.parse('https://api.cookie-api.com/api/discord/oauth2/applications/delete')

params = { 'client_id' => '1234567890' }
uri.query = URI.encode_www_form(params)

request = Net::HTTP::Delete.new(uri)
request['Authorization'] = 'API_Key'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

puts response.body

Rust

use reqwest::blocking::Client;
use reqwest::header::HeaderMap;
use reqwest::Url;

fn main() {
    let url = Url::parse("https://api.cookie-api.com/api/discord/oauth2/applications/delete")
        .unwrap()
        .query_pairs_mut()
        .append_pair("client_id", "1234567890")
        .finish();

    let client = Client::new();
    let mut headers = HeaderMap::new();
    headers.insert("Authorization", "API_Key".parse().unwrap());

    let res = client
        .delete(url)
        .headers(headers)
        .send()
        .unwrap();

    println!("{}", res.text().unwrap());
}

Responses

200

{
    "message": "Application deleted successfully",
    "success": true
}

---

List all verified Users

Lists all verified users from a specified bot.

Danger

Verified users are saved for 2 days. After that, they are deleted from the database. Only up to 500 users can be retrieved in one API Request.

GET /api/discord/oauth2/users/list

https://api.cookie-api.com/api/discord/oauth2/users/list

Authentication Learn how to get your API Key and use it in your requests!

URL Parameters
client_id	Your OAuth2 client ID from what all verified users should be returned from
filter_user_id (optional)	Filter to a specific discord user id

cURL

curl --location 'https://api.cookie-api.com/api/discord/oauth2/users/list?client_id=1234567890' \
--header 'Authorization: API_Key'

Python

import requests

url = 'https://api.cookie-api.com/api/discord/oauth2/users/list'
headers = {
    'Authorization': 'API_Key'
}
params = {
    'client_id': '1234567890'
}

response = requests.get(url, headers=headers, params=params)
print(response.json())

JavaScript

const fetch = require('node-fetch');

const url = 'https://api.cookie-api.com/api/discord/oauth2/users/list?client_id=1234567890';
const headers = {
    'Authorization': 'API_Key'
};

fetch(url, {
    method: 'GET',
    headers
})
.then(res => res.json())
.then(data => console.log(data))
.catch(err => console.error(err));

Go

package main

import (
    "fmt"
    "log"
    "net/http"
    "net/url"
)

func main() {
    baseURL := "https://api.cookie-api.com/api/discord/oauth2/users/list"
    clientID := "1234567890"
    urlParams := url.Values{}
    urlParams.Add("client_id", clientID)
    urlWithParams := fmt.Sprintf("%s?%s", baseURL, urlParams.Encode())

    req, err := http.NewRequest("GET", urlWithParams, nil)
    if err != nil {
        log.Fatal(err)
    }

    req.Header.Set("Authorization", "API_Key")

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        log.Fatal(err)
    }
    defer resp.Body.Close()

    fmt.Println("Response Status:", resp.Status)
}

Node.js

const https = require('https');

const options = {
    hostname: 'api.cookie-api.com',
    path: '/api/discord/oauth2/users/list?client_id=1234567890',
    method: 'GET',
    headers: {
        'Authorization': 'API_Key'
    }
};

const req = https.request(options, res => {
    let responseData = '';
    res.on('data', chunk => {
        responseData += chunk;
    });
    res.on('end', () => {
        console.log(JSON.parse(responseData));
    });
});

req.on('error', error => {
    console.error(error);
});

req.end();

Ruby

require 'net/http'
require 'uri'
require 'json'

uri = URI.parse('https://api.cookie-api.com/api/discord/oauth2/users/list')

params = { 'client_id' => '1234567890' }
uri.query = URI.encode_www_form(params)

request = Net::HTTP::Get.new(uri)
request['Authorization'] = 'API_Key'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

puts response.body

Rust

use reqwest::blocking::Client;
use reqwest::header::HeaderMap;
use reqwest::Url;

fn main() {
    let url = Url::parse("https://api.cookie-api.com/api/discord/oauth2/users/list")
        .unwrap()
        .query_pairs_mut()
        .append_pair("client_id", "1234567890")
        .finish();

    let client = Client::new();
    let mut headers = HeaderMap::new();
    headers.insert("Authorization", "API_Key".parse().unwrap());

    let res = client
        .get(url)
        .headers(headers)
        .send()
        .unwrap();

    println!("{}", res.text().unwrap());
}

Responses

200

{
    "data": [
        {
            "access_token": "sadopim3298jmd98ma9832890dsa89dsa",
            "authorized_at": "1736455446",
            "discord_data": {
                "accent_color": null,
                "avatar": "d6f8e1b9a83947d1b12f84c299f7482b",
                "avatar_decoration_data": null,
                "banner": null,
                "banner_color": null,
                "clan": null,
                "discriminator": "1234",
                "flags": 0,
                "global_name": "JohnDoe",
                "id": "1234567890123456789",
                "locale": "en",
                "mfa_enabled": false,
                "premium_type": 1,
                "primary_guild": null,
                "public_flags": 0,
                "username": "john_doe123"
            },
            "refresh_token": "a9mdo93u48nfg394mng4gm43gkm49gmn",
            "user_id": "1234567890123456789"
        },
        {
            "access_token": "93nd09sadsadf23423sd4234nmf3mnfg",
            "authorized_at": "1736455584",
            "discord_data": {
                "accent_color": null,
                "avatar": "ad9f84b7c239487ed8213f94a7c19fb8",
                "avatar_decoration_data": null,
                "banner": null,
                "banner_color": null,
                "clan": null,
                "discriminator": "5678",
                "flags": 0,
                "global_name": "JaneDoe",
                "id": "9876543210987654321",
                "locale": "es",
                "mfa_enabled": true,
                "premium_type": 2,
                "primary_guild": null,
                "public_flags": 0,
                "username": "jane_doe456"
            },
            "refresh_token": "9masdf9023mfa8ndf93284msdfasdf23",
            "user_id": "9876543210987654321"
        },
        {
            "access_token": "asd8298ndf9n3rf9823nfg09wnf9032",
            "authorized_at": "1736456226",
            "discord_data": {
                "accent_color": 123456,
                "avatar": "b1d7c84f839491b89a2c93f7a1e94a2c",
                "avatar_decoration_data": null,
                "banner": null,
                "banner_color": null,
                "clan": null,
                "discriminator": "9012",
                "flags": 0,
                "global_name": "AlexSmith",
                "id": "1122334455667788990",
                "locale": "fr",
                "mfa_enabled": false,
                "premium_type": 1,
                "primary_guild": null,
                "public_flags": 0,
                "username": "alex_smith789"
            },
            "refresh_token": "df9ma9sd8f93nq0w93mnc84mf2309wnc",
            "user_id": "1122334455667788990"
        },
        {
            "access_token": "2093rfnm98qwf92w3mc9wefw23f92n23",
            "authorized_at": "1736457326",
            "discord_data": {
                "accent_color": null,
                "avatar": "c1e83f7b9d94f18b2c948f3a7c1d2f3e",
                "avatar_decoration_data": null,
                "banner": null,
                "banner_color": null,
                "clan": null,
                "discriminator": "3456",
                "flags": 0,
                "global_name": "CharlieBrown",
                "id": "3344556677889900112",
                "locale": "de",
                "mfa_enabled": true,
                "premium_type": 2,
                "primary_guild": null,
                "public_flags": 0,
                "username": "charlie_brown123"
            },
            "refresh_token": "908qwefj98qnwef0293mcnwe09wefwe23",
            "user_id": "3344556677889900112"
        }
    ],
    "results": 4,
    "success": true
}

---

Delete a user from the database

Deletes a verified user from the database

Delete /api/discord/oauth2/users/delete

https://api.cookie-api.com/api/discord/oauth2/users/delete

Authentication Learn how to get your API Key and use it in your requests!

Body

{
    "client_id": "Client ID the user has been authorized with",
    "client_secret": "Target user the data should be deleted of"
}

cURL

curl --location --request DELETE 'https://api.cookie-api.com/api/discord/oauth2/users/delete?client_id=1234567890&user_id=1234567890' \
--header 'Authorization: API_Key'

Python

import requests

url = 'https://api.cookie-api.com/api/discord/oauth2/users/delete'
headers = {
    'Authorization': 'API_Key'
}
params = {
    'client_id': '1234567890',
    'user_id': '1234567890'
}

response = requests.delete(url, headers=headers, params=params)
print(response.json())

JavaScript

const fetch = require('node-fetch');

const url = 'https://api.cookie-api.com/api/discord/oauth2/users/delete?client_id=1234567890&user_id=1234567890';
const headers = {
    'Authorization': 'API_Key'
};

fetch(url, {
    method: 'DELETE',
    headers
})
.then(res => res.json())
.then(data => console.log(data))
.catch(err => console.error(err));

Go

package main

import (
    "fmt"
    "log"
    "net/http"
    "net/url"
)

func main() {
    baseURL := "https://api.cookie-api.com/api/discord/oauth2/users/delete"
    clientID := "1234567890"
    userID := "1234567890"
    urlParams := url.Values{}
    urlParams.Add("client_id", clientID)
    urlParams.Add("user_id", userID)
    urlWithParams := fmt.Sprintf("%s?%s", baseURL, urlParams.Encode())

    req, err := http.NewRequest("DELETE", urlWithParams, nil)
    if err != nil {
        log.Fatal(err)
    }

    req.Header.Set("Authorization", "API_Key")

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        log.Fatal(err)
    }
    defer resp.Body.Close()

    fmt.Println("Response Status:", resp.Status)
}

Node.js

const https = require('https');

const options = {
    hostname: 'api.cookie-api.com',
    path: '/api/discord/oauth2/users/delete?client_id=1234567890&user_id=1234567890',
    method: 'DELETE',
    headers: {
        'Authorization': 'API_Key'
    }
};

const req = https.request(options, res => {
    let responseData = '';
    res.on('data', chunk => {
        responseData += chunk;
    });
    res.on('end', () => {
        console.log(JSON.parse(responseData));
    });
});

req.on('error', error => {
    console.error(error);
});

req.end();

Ruby

require 'net/http'
require 'uri'
require 'json'

uri = URI.parse('https://api.cookie-api.com/api/discord/oauth2/users/delete')

params = { 'client_id' => '1234567890', 'user_id' => '1234567890' }
uri.query = URI.encode_www_form(params)

request = Net::HTTP::Delete.new(uri)
request['Authorization'] = 'API_Key'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

puts response.body

Rust

use reqwest::blocking::Client;
use reqwest::header::HeaderMap;
use reqwest::Url;

fn main() {
    let url = Url::parse("https://api.cookie-api.com/api/discord/oauth2/users/delete")
        .unwrap()
        .query_pairs_mut()
        .append_pair("client_id", "1234567890")
        .append_pair("user_id", "1234567890")
        .finish();

    let client = Client::new();
    let mut headers = HeaderMap::new();
    headers.insert("Authorization", "API_Key".parse().unwrap());

    let res = client
        .delete(url)
        .headers(headers)
        .send()
        .unwrap();

    println!("{}", res.text().unwrap());
}

Responses

200

{
    "message": "User data deleted successfully",
    "success": true
}