User Management

List Join requests

List Current Join Requests in the group

GET /api/roblox/group/join-requests/list

https://api.cookie-api.com/api/roblox/group/join-requests/list

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

URL Parameters
workspace_id	`<workspace id>`

curl --location 'https://api.cookie-api.com/api/roblox/group/join-requests/list?workspace_id=12345' \
--header 'Authorization: API_Key'

import requests

url = 'https://api.cookie-api.com/api/roblox/group/join-requests/list?workspace_id=12345'
headers = {
    'Authorization': 'API_Key'
}

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

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

const url = 'https://api.cookie-api.com/api/roblox/group/join-requests/list?workspace_id=12345';
const headers = {
    'Authorization': 'API_Key'
};

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

package main

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

func main() {
    url := "https://api.cookie-api.com/api/roblox/group/join-requests/list?workspace_id=12345"
    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()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        log.Fatal(err)
    }

    fmt.Println(string(body))
}

const https = require('https');

const options = {
    hostname: 'api.cookie-api.com',
    path: '/api/roblox/group/join-requests/list?workspace_id=12345',
    method: 'GET',
    headers: {
        'Authorization': 'API_Key'
    }
};

const req = https.request(options, res => {
    let body = '';

    res.on('data', chunk => {
        body += chunk;
    });

    res.on('end', () => {
        console.log(body);
    });
});

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

req.end();

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

uri = URI.parse('https://api.cookie-api.com/api/roblox/group/join-requests/list?workspace_id=12345')
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

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

fn main() {
    let url = "https://api.cookie-api.com/api/roblox/group/join-requests/list?workspace_id=12345";
    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

{
    "requests": [
        {
            "created": "2025-04-03T15:47:13.773Z",
            "requester": {
                "displayName": "thiscookie9",
                "hasVerifiedBadge": false,
                "userId": 5460701217,
                "username": "thiscookie9"
            }
        }
    ],
    "success": true
}

Accept User

Accept user with optional rank

POST /api/roblox/group/join-requests/accept

https://api.cookie-api.com/api/roblox/group/join-requests/accept

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

URL Parameters
workspace_id	`<workspace id>`

Body

{
    "user_id": "number"
    "rank_id": number, // optional
}

curl --location 'https://api.cookie-api.com/api/roblox/group/join-requests/accept?workspace_id=12345' \
--header 'Authorization: API_Key' \
--header 'Content-Type: application/json' \
--data '{
    "rank_id": 253,
    "user_id": "5460701217"
}'

import requests
import json

url = 'https://api.cookie-api.com/api/roblox/group/join-requests/accept?workspace_id=12345'
headers = {
    'Authorization': 'API_Key',
    'Content-Type': 'application/json'
}
data = {
    'rank_id': 253,
    'user_id': '5460701217'
}

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

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

const url = 'https://api.cookie-api.com/api/roblox/group/join-requests/accept?workspace_id=12345';
const headers = {
    'Authorization': 'API_Key',
    'Content-Type': 'application/json'
};
const data = {
    rank_id: 253,
    user_id: '5460701217'
};

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

package main

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

func main() {
    url := "https://api.cookie-api.com/api/roblox/group/join-requests/accept?workspace_id=12345"
    data := map[string]interface{}{
        "rank_id": 253,
        "user_id": "5460701217",
    }

    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)
}

const https = require('https');

const options = {
    hostname: 'api.cookie-api.com',
    path: '/api/roblox/group/join-requests/accept?workspace_id=12345',
    method: 'POST',
    headers: {
        'Authorization': 'API_Key',
        'Content-Type': 'application/json'
    }
};

const data = JSON.stringify({
    rank_id: 253,
    user_id: '5460701217'
});

const req = https.request(options, res => {
    let body = '';

    res.on('data', chunk => {
        body += chunk;
    });

    res.on('end', () => {
        console.log(body);
    });
});

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

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

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

uri = URI.parse('https://api.cookie-api.com/api/roblox/group/join-requests/accept?workspace_id=12345')
request = Net::HTTP::Post.new(uri)
request['Authorization'] = 'API_Key'
request['Content-Type'] = 'application/json'

data = {
  'rank_id' => 253,
  'user_id' => '5460701217'
}
request.body = data.to_json

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

puts response.body

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

fn main() {
    let url = "https://api.cookie-api.com/api/roblox/group/join-requests/accept?workspace_id=12345";
    let client = Client::new();

    let mut headers = HeaderMap::new();
    headers.insert("Authorization", "API_Key".parse().unwrap());
    headers.insert("Content-Type", "application/json".parse().unwrap());

    let body = json!({
        "rank_id": 253,
        "user_id": "5460701217"
    });

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

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

Responses

{
    "success": true
}

Deny User

Denies user to enter the group.

DELETE /api/roblox/group/join-requests/deny

https://api.cookie-api.com/api/roblox/group/join-requests/deny

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

URL Parameters
workspace_id	`<workspace id>`

Body

{
    "user_id": 5460701217
}

curl --location --request DELETE 'https://api.cookie-api.com/api/roblox/group/join-requests/deny?workspace_id=12345' \
--header 'Authorization: API_Key' \
--header 'Content-Type: application/json' \
--data '{
    "user_id": 5460701217
}'

import requests
import json

url = 'https://api.cookie-api.com/api/roblox/group/join-requests/deny?workspace_id=12345'
headers = {
    'Authorization': 'API_Key',
    'Content-Type': 'application/json'
}
data = {
    'user_id': 5460701217
}

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

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

const url = 'https://api.cookie-api.com/api/roblox/group/join-requests/deny?workspace_id=12345';
const headers = {
    'Authorization': 'API_Key',
    'Content-Type': 'application/json'
};
const data = {
    user_id: 5460701217
};

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

package main

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

func main() {
    url := "https://api.cookie-api.com/api/roblox/group/join-requests/deny?workspace_id=12345"
    data := map[string]interface{}{
        "user_id": 5460701217,
    }

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

    req, err := http.NewRequest("DELETE", 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)
}

const https = require('https');

const options = {
    hostname: 'api.cookie-api.com',
    path: '/api/roblox/group/join-requests/deny?workspace_id=12345',
    method: 'DELETE',
    headers: {
        'Authorization': 'API_Key',
        'Content-Type': 'application/json'
    }
};

const data = JSON.stringify({
    user_id: 5460701217
});

const req = https.request(options, res => {
    let body = '';

    res.on('data', chunk => {
        body += chunk;
    });

    res.on('end', () => {
        console.log(body);
    });
});

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

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

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

uri = URI.parse('https://api.cookie-api.com/api/roblox/group/join-requests/deny?workspace_id=12345')
request = Net::HTTP::Delete.new(uri)
request['Authorization'] = 'API_Key'
request['Content-Type'] = 'application/json'

data = {
  'user_id' => 5460701217
}
request.body = data.to_json

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

puts response.body

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

fn main() {
    let url = "https://api.cookie-api.com/api/roblox/group/join-requests/deny?workspace_id=12345";
    let client = Client::new();

    let mut headers = HeaderMap::new();
    headers.insert("Authorization", "API_Key".parse().unwrap());
    headers.insert("Content-Type", "application/json".parse().unwrap());

    let body = json!({
        "user_id": 5460701217
    });

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

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

Responses

{
    "success": true
}

Edit Role

Edits users’ group role

PATCH /api/roblox/group/edit-role

https://api.cookie-api.com/api/roblox/group/edit-role

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

URL Parameters
workspace_id	`<workspace id>`

Body

{
    "rank_id": "number",
    "user_id": "number"
}

curl --location --request PATCH 'https://api.cookie-api.com/api/roblox/group/edit-role?workspace_id=12345' \
--header 'Authorization: API_Key' \
--header 'Content-Type: application/json' \
--data '{
    "rank_id": "253",
    "user_id": "5460701217"
}'

import requests
import json

url = 'https://api.cookie-api.com/api/roblox/group/edit-role?workspace_id=12345'
headers = {
    'Authorization': 'API_Key',
    'Content-Type': 'application/json'
}
data = {
    'rank_id': '253',
    'user_id': '5460701217'
}

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

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

const url = 'https://api.cookie-api.com/api/roblox/group/edit-role?workspace_id=12345';
const headers = {
    'Authorization': 'API_Key',
    'Content-Type': 'application/json'
};
const data = {
    rank_id: '253',
    user_id: '5460701217'
};

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

package main

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

func main() {
    url := "https://api.cookie-api.com/api/roblox/group/edit-role?workspace_id=12345"
    data := map[string]interface{}{
        "rank_id": "253",
        "user_id": "5460701217",
    }

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

    req, err := http.NewRequest("PATCH", 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)
}

const https = require('https');

const options = {
    hostname: 'api.cookie-api.com',
    path: '/api/roblox/group/edit-role?workspace_id=12345',
    method: 'PATCH',
    headers: {
        'Authorization': 'API_Key',
        'Content-Type': 'application/json'
    }
};

const data = JSON.stringify({
    rank_id: '253',
    user_id: '5460701217'
});

const req = https.request(options, res => {
    let body = '';

    res.on('data', chunk => {
        body += chunk;
    });

    res.on('end', () => {
        console.log(body);
    });
});

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

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

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

uri = URI.parse('https://api.cookie-api.com/api/roblox/group/edit-role?workspace_id=12345')
request = Net::HTTP::Patch.new(uri)
request['Authorization'] = 'API_Key'
request['Content-Type'] = 'application/json'

data = {
  'rank_id' => '253',
  'user_id' => '5460701217'
}
request.body = data.to_json

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

puts response.body

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

fn main() {
    let url = "https://api.cookie-api.com/api/roblox/group/edit-role?workspace_id=12345";
    let client = Client::new();

    let mut headers = HeaderMap::new();
    headers.insert("Authorization", "API_Key".parse().unwrap());
    headers.insert("Content-Type", "application/json".parse().unwrap());

    let body = json!({
        "rank_id": "253",
        "user_id": "5460701217"
    });

    let res = client
        .patch(url)
        .headers(headers)
        .json(&body)
        .send()
        .unwrap();

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

Responses

{
    "success": true
}

Kick User

Kicks user from the group

DELETE /api/roblox/group/kick

https://api.cookie-api.com/api/roblox/group/kick

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

URL Parameters
workspace_id	`<workspace id>`

Body

{
    "user_id": "number"
}

curl --location --request DELETE 'https://api.cookie-api.com/api/roblox/group/kick?workspace_id=12345' \
--header 'Authorization: API_Key' \
--header 'Content-Type: application/json' \
--data '{
    "user_id": 5460701217
}'

import requests
import json

url = 'https://api.cookie-api.com/api/roblox/group/kick?workspace_id=12345'
headers = {'Authorization': 'API_Key', 'Content-Type': 'application/json'}
payload = {"user_id": 5460701217}

response = requests.delete(url, headers=headers, data=json.dumps(payload))

print(response.json())

const axios = require('axios');

const url = 'https://api.cookie-api.com/api/roblox/group/kick?workspace_id=12345';
const headers = {
  Authorization: 'API_Key',
  'Content-Type': 'application/json'
};
const data = { user_id: 5460701217 };

axios.delete(url, { headers, data })
  .then(response => console.log(response.data))
  .catch(error => console.error(error));

package main

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

func main() {
  url := "https://api.cookie-api.com/api/roblox/group/kick?workspace_id=12345"
  payload := map[string]interface{}{"user_id": 5460701217}
  jsonData, err := json.Marshal(payload)
  if err != nil {
    log.Fatal(err)
  }

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

  req.Header.Add("Authorization", "API_Key")
  req.Header.Add("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)
}

const https = require('https');

const data = JSON.stringify({
  user_id: 5460701217
});

const options = {
  hostname: 'api.cookie-api.com',
  path: '/api/roblox/group/kick?workspace_id=12345',
  method: 'DELETE',
  headers: {
    'Authorization': 'API_Key',
    'Content-Type': 'application/json',
    'Content-Length': data.length
  }
};

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

  res.on('end', () => {
    console.log(responseData);
  });
});

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

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

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

url = URI.parse('https://api.cookie-api.com/api/roblox/group/kick?workspace_id=12345')
request = Net::HTTP::Delete.new(url)
request['Authorization'] = 'API_Key'
request['Content-Type'] = 'application/json'
request.body = { user_id: 5460701217 }.to_json

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

puts JSON.parse(response.body)

use reqwest::header::{HeaderMap, AUTHORIZATION};
use reqwest::Client;
use serde_json::json;

#[tokio::main]
async fn main() {
    let url = "https://api.cookie-api.com/api/roblox/group/kick?workspace_id=12345";
    let client = Client::new();

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

    let res = client.delete(url)
        .headers(headers)
        .json(&json!({
            "user_id": 5460701217
        }))
        .send()
        .await
        .unwrap()
        .text()
        .await
        .unwrap();

    println!("{:?}", res);
}

Responses

{
    "success": true
}

List Banned Users

Lists groups’ banned users

GET /api/roblox/group/ban/list

https://api.cookie-api.com/api/roblox/group/ban/list

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

URL Parameters
workspace_id	`<workspace id>`

curl --location 'https://api.cookie-api.com/api/roblox/group/ban/list?workspace_id=12345' \
--header 'Authorization: API_Key'

import requests

url = 'https://api.cookie-api.com/api/roblox/group/ban/list?workspace_id=12345'
headers = {'Authorization': 'API_Key'}
response = requests.get(url, headers=headers)
print(response.json())

const axios = require('axios');

const url = 'https://api.cookie-api.com/api/roblox/group/ban/list?workspace_id=12345';
const headers = { Authorization: 'API_Key' };

axios.get(url, { headers })
  .then(response => console.log(response.data))
  .catch(error => console.error(error));

package main

import (
  "fmt"
  "log"
  "net/http"
  "io/ioutil"
  "bytes"
)

func main() {
  url := "https://api.cookie-api.com/api/roblox/group/ban/list?workspace_id=12345"
  req, err := http.NewRequest("GET", url, nil)
  if err != nil {
    log.Fatal(err)
  }

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

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

  body, err := ioutil.ReadAll(resp.Body)
  if err != nil {
    log.Fatal(err)
  }

  fmt.Println(string(body))
}

const https = require('https');

const options = {
  hostname: 'api.cookie-api.com',
  path: '/api/roblox/group/ban/list?workspace_id=12345',
  method: 'GET',
  headers: {
    'Authorization': 'API_Key'
  }
};

const req = https.request(options, (res) => {
  let data = '';

  res.on('data', (chunk) => {
    data += chunk;
  });

  res.on('end', () => {
    console.log(JSON.parse(data));
  });
});

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

req.end();

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

url = URI.parse('https://api.cookie-api.com/api/roblox/group/ban/list?workspace_id=12345')
request = Net::HTTP::Get.new(url)
request['Authorization'] = 'API_Key'

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

puts JSON.parse(response.body)

use reqwest::header::{HeaderMap, AUTHORIZATION};
use reqwest::Client;
use serde_json::Value;

#[tokio::main]
async fn main() {
    let url = "https://api.cookie-api.com/api/roblox/group/ban/list?workspace_id=12345";
    let client = Client::new();

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

    let res = client.get(url)
        .headers(headers)
        .send()
        .await
        .unwrap()
        .json::<Value>()
        .await
        .unwrap();

    println!("{:?}", res);
}

Responses

{
    "bans": {
        "data": [
            {
                "actingUser": {
                    "role": {
                        "id": 103891662,
                        "name": "Owner",
                        "rank": 255
                    },
                    "user": {
                        "displayName": "The_Cookie",
                        "hasVerifiedBadge": false,
                        "userId": 4635563910,
                        "username": "Cooki080820"
                    }
                },
                "created": "2025-04-03T16:33:37.217Z",
                "user": {
                    "displayName": "thiscookie9",
                    "hasVerifiedBadge": false,
                    "userId": 5460701217,
                    "username": "thiscookie9"
                }
            }
        ],
        "nextPageCursor": null,
        "previousPageCursor": null
    },
    "success": true
}

Ban User

Bans user from the group.

POST /api/roblox/group/ban

https://api.cookie-api.com/api/roblox/group/ban

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

URL Parameters
workspace_id	`<workspace id>`

Body

{
    "user_id": "number"
}

curl --location 'https://api.cookie-api.com/api/roblox/group/ban?workspace_id=12345' \
--header 'Authorization: API_Key' \
--header 'Content-Type: application/json' \
--data '{
    "user_id": "5460701217"
}'

import requests

url = 'https://api.cookie-api.com/api/roblox/group/ban?workspace_id=12345'
headers = {
    'Authorization': 'API_Key',
    'Content-Type': 'application/json'
}
data = {
    'user_id': '5460701217'
}

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

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

const url = 'https://api.cookie-api.com/api/roblox/group/ban?workspace_id=12345';
const headers = {
    'Authorization': 'API_Key',
    'Content-Type': 'application/json'
};
const body = JSON.stringify({
    user_id: '5460701217'
});

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

package main

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

func main() {
    url := "https://api.cookie-api.com/api/roblox/group/ban?workspace_id=12345"
    jsonData := map[string]interface{}{
        "user_id": "5460701217",
    }
    jsonValue, _ := json.Marshal(jsonData)

    req, err := http.NewRequest("DELETE", url, bytes.NewBuffer(jsonValue))
    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)
}

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

const url = 'https://api.cookie-api.com/api/roblox/group/ban?workspace_id=12345';
const headers = {
    'Authorization': 'API_Key',
    'Content-Type': 'application/json'
};
const body = JSON.stringify({
    user_id: '5460701217'
});

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

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

uri = URI.parse("https://api.cookie-api.com/api/roblox/group/ban?workspace_id=12345")
request = Net::HTTP::Delete.new(uri)
request["Authorization"] = "API_Key"
request["Content-Type"] = "application/json"
request.body = { "user_id": "5460701217" }.to_json

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

puts response.body

use reqwest::blocking::Client;
use serde::Serialize;

#[derive(Serialize)]
struct BanUser {
    user_id: String,
}

fn main() {
    let client = Client::new();
    let url = "https://api.cookie-api.com/api/roblox/group/ban?workspace_id=12345";

    let ban_user = BanUser {
        user_id: "5460701217".to_string(),
    };

    let response = client
        .delete(url)
        .json(&ban_user)
        .header("Authorization", "API_Key")
        .header("Content-Type", "application/json")
        .send()
        .unwrap();

    println!("{:?}", response.text().unwrap());
}

Responses

{
    "success": true
}

Remove Ban from User

Removes users’ ban from the group.

DELETE /api/roblox/group/unban

https://api.cookie-api.com/api/roblox/group/unban

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

URL Parameters
workspace_id	`<workspace id>`

Body

{
    "user_id": "number"
}

curl --location --request DELETE 'https://api.cookie-api.com/api/roblox/group/unban?workspace_id=12345' \
--header 'Authorization: API_Key' \
--header 'Content-Type: application/json' \
--data '{
    "user_id": "5460701217"
}'

import requests

url = 'https://api.cookie-api.com/api/roblox/group/unban?workspace_id=12345'
headers = {
    'Authorization': 'API_Key',
    'Content-Type': 'application/json'
}
data = {
    'user_id': '5460701217'
}

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

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

const url = 'https://api.cookie-api.com/api/roblox/group/unban?workspace_id=12345';
const headers = {
    'Authorization': 'API_Key',
    'Content-Type': 'application/json'
};
const body = JSON.stringify({
    user_id: '5460701217'
});

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

package main

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

func main() {
    url := "https://api.cookie-api.com/api/roblox/group/unban?workspace_id=12345"
    jsonData := map[string]interface{}{
        "user_id": "5460701217",
    }
    jsonValue, _ := json.Marshal(jsonData)

    req, err := http.NewRequest("DELETE", url, bytes.NewBuffer(jsonValue))
    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)
}

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

const url = 'https://api.cookie-api.com/api/roblox/group/unban?workspace_id=12345';
const headers = {
    'Authorization': 'API_Key',
    'Content-Type': 'application/json'
};
const body = JSON.stringify({
    user_id: '5460701217'
});

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

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

uri = URI.parse("https://api.cookie-api.com/api/roblox/group/unban?workspace_id=12345")
request = Net::HTTP::Delete.new(uri)
request["Authorization"] = "API_Key"
request["Content-Type"] = "application/json"
request.body = { "user_id": "5460701217" }.to_json

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

puts response.body

use reqwest::blocking::Client;
use serde::Serialize;

#[derive(Serialize)]
struct UnbanUser {
    user_id: String,
}

fn main() {
    let client = Client::new();
    let url = "https://api.cookie-api.com/api/roblox/group/unban?workspace_id=12345";

    let unban_user = UnbanUser {
        user_id: "5460701217".to_string(),
    };

    let response = client
        .delete(url)
        .json(&unban_user)
        .header("Authorization", "API_Key")
        .header("Content-Type", "application/json")
        .send()
        .unwrap();

    println!("{:?}", response.text().unwrap());
}

Responses

{
    "success": true
}