Group Relationships

List Pending Requests

List incoming relationship requests

GET /api/roblox/group/relationship/requests

https://api.cookie-api.com/api/roblox/group/relationship/requests

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/relationship/requests?workspace_id=12345' \
--header 'Authorization: API_Key'

import requests

url = 'https://api.cookie-api.com/api/roblox/group/relationship/requests?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/relationship/requests?workspace_id=12345';
const headers = {
    'Authorization': 'API_Key'
};

fetch(url, { method: 'GET', 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/relationship/requests?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/relationship/requests?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(JSON.parse(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/relationship/requests?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/relationship/requests?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": {
        "groupId": 33545359,
        "nextRowIndex": 50,
        "relatedGroups": [
            {
                "description": "Apparently this was a request from a scam group which is why i removed it here :D",
                "hasVerifiedBadge": false,
                "id": 1234567,
                "isBuildersClubOnly": false,
                "memberCount": 34782,
                "name": "Censored",
                "owner": {
                    "displayName": "Funny scammer",
                    "hasVerifiedBadge": false,
                    "userId": 12345677,
                    "username": "Funny scammer"
                },
                "publicEntryAllowed": true,
                "shout": null
            }
        ],
        "relationshipType": "Allies",
        "totalGroupCount": 1
    },
    "success": true
}

Accept Relationship Request

Accepts incomnig group relationship request.

POST /api/roblox/group/relationship/accept

https://api.cookie-api.com/api/roblox/group/relationship/accept

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

URL Parameters
workspace_id	`<workspace id>`

Body

{
    "relation_type": "ally",
    "group_id": "number"
}

curl --location 'https://api.cookie-api.com/api/roblox/group/relationship/accept?workspace_id=12345' \
--header 'Authorization: API_Key' \
--header 'Content-Type: application/json' \
--data '{
    "relation_type": "ally",
    "group_id": 123456
}'

import requests
import json

url = 'https://api.cookie-api.com/api/roblox/group/relationship/accept?workspace_id=12345'
headers = {
    'Authorization': 'API_Key',
    'Content-Type': 'application/json'
}
data = {
    "relation_type": "ally",
    "group_id": 123456
}

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

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

const url = 'https://api.cookie-api.com/api/roblox/group/relationship/accept?workspace_id=12345';
const headers = {
    'Authorization': 'API_Key',
    'Content-Type': 'application/json'
};
const data = {
    relation_type: 'ally',
    group_id: 123456
};

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

package main

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

type RequestBody struct {
    RelationType string `json:"relation_type"`
    GroupID      int    `json:"group_id"`
}

func main() {
    url := "https://api.cookie-api.com/api/roblox/group/relationship/accept?workspace_id=12345"
    requestBody := RequestBody{
        RelationType: "ally",
        GroupID:      123456,
    }

    jsonData, err := json.Marshal(requestBody)
    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 data = JSON.stringify({
    relation_type: 'ally',
    group_id: 123456
});

const options = {
    hostname: 'api.cookie-api.com',
    path: '/api/roblox/group/relationship/accept?workspace_id=12345',
    method: 'POST',
    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(JSON.parse(responseData));
    });
});

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

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

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

url = URI.parse('https://api.cookie-api.com/api/roblox/group/relationship/accept?workspace_id=12345')
request = Net::HTTP::Post.new(url)
request['Authorization'] = 'API_Key'
request['Content-Type'] = 'application/json'
request.body = {
  relation_type: 'ally',
  group_id: 123456
}.to_json

response = Net::HTTP.start(url.hostname, url.port) { |http| http.request(request) }

puts JSON.parse(response.body)

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

#[derive(Serialize)]
struct RequestBody {
    relation_type: String,
    group_id: i32,
}

fn main() {
    let url = "https://api.cookie-api.com/api/roblox/group/relationship/accept?workspace_id=12345";
    let request_body = RequestBody {
        relation_type: "ally".to_string(),
        group_id: 123456,
    };

    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 res = client.post(url)
        .headers(headers)
        .json(&request_body)
        .send()
        .unwrap();

    let body: Value = res.json().unwrap();
    println!("{:?}", body);
}

Responses

{
    "success": true
}

curl --location --request DELETE 'https://api.cookie-api.com/api/roblox/group/relationship/deny?workspace_id=12345' \
--header 'Authorization: API_Key' \
--header 'Content-Type: application/json' \
--data '{
    "group_id": 123456,
    "relation_type": "ally"
}'

Deny Relationship

Denies incoming group Relationship

DELETE /api/roblox/group/relationship/deny

https://api.cookie-api.com/api/roblox/group/relationship/deny

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

URL Parameters
workspace_id	`<workspace id>`

curl --location --request DELETE 'https://api.cookie-api.com/api/roblox/group/relationship/deny?workspace_id=12345' \
--header 'Authorization: API_Key' \
--header 'Content-Type: application/json' \
--data '{
    "group_id": 123456,
    "relation_type": "ally"
}'

Body

{
    "relation_type": "ally",
    "group_id": "number"
}

Responses

{
    "success": true
}

Delete Relationship

Deletes group relationship

DELETE /api/roblox/group/relationship/delete

https://api.cookie-api.com/api/roblox/group/relationship/delete

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

URL Parameters
workspace_id	`<workspace id>`

Body

{
    "relation_type": "ally",
    "group_id": "number"
}

curl --location --request DELETE 'https://api.cookie-api.com/api/roblox/group/relationship/delete?workspace_id=12345' \
--header 'Authorization: API_Key' \
--header 'Content-Type: application/json' \
--data '{
    "group_id": 123456,
    "relation_type": "ally"
}'

Responses

{
    "success": true
}