RequestRocket Documentation
API ReferenceCore API

Invites API

Send and manage team invitations

Invites API

Send and manage invitations to join your organisation.

Client Invite Endpoints

MethodEndpointDescription
GET/api/clients/{clientId}/invitesList all pending invites for a client
POST/api/clients/{clientId}/invitesCreate a new invite
GET/api/clients/{clientId}/invites/{inviteId}Get invite details
PUT/api/clients/{clientId}/invites/{inviteId}Update an invite
DELETE/api/clients/{clientId}/invites/{inviteId}Cancel an invite

User Invite Endpoints

MethodEndpointDescription
GET/api/users/{userId}/invitesList all invites sent to a user
GET/api/users/{userId}/invites/{inviteId}Get a specific invite
POST/api/users/{userId}/invitesNot supported
PUT/api/users/{userId}/invites/{inviteId}Accept an invite
DELETE/api/users/{userId}/invites/{inviteId}Reject/decline an invite

List Client Invites

Get all pending invitations for a client (organisation).

Request

GET /api/clients/{clientId}/invites HTTP/1.1
Host: api.requestrocket.com
Authorization: {user_token}

Response

{
  "invites": [
    {
      "clientName": "Acme Corporation",
      "inviteId": "95c594c9-8a98-4aeb-ae3c-bad251bc3ce2",
      "pKey": "INVITATION",
      "roles": [
        "user"
      ],
      "userEmail": "colleague@example.com",
      "parentId": "550e8400-e29b-41d4-a716-446655440000",
      "TTL": 1770288917,
      "sKey": "95c594c9-8a98-4aeb-ae3c-bad251bc3ce2"
    }
  ],
  "message": "Success"
}

Example

const response = await fetch(
  `https://api.requestrocket.com/api/clients/${clientId}/invites`,
  {
    headers: {
      'Authorization': process.env.USER_TOKEN
    }
  }
);

const data = await response.json();
console.log('Pending invites:', data.invites);
import requests
import os

client_id = "your-client-id"

response = requests.get(
    f'https://api.requestrocket.com/api/clients/{client_id}/invites',
    headers={'Authorization': os.getenv('USER_TOKEN')}
)

data = response.json()
print(f"Found {len(data['invites'])} pending invites")
package main

import (
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "os"
)

type Invite struct {
    ClientName string   `json:"clientName"`
    InviteId   string   `json:"inviteId"`
    PKey       string   `json:"pKey"`
    Roles      []string `json:"roles"`
    UserEmail  string   `json:"userEmail"`
    ParentId   string   `json:"parentId"`
    TTL        int64    `json:"TTL"`
    SKey       string   `json:"sKey"`
}

type Response struct {
    Invites []Invite `json:"invites"`
    Message string   `json:"message"`
}

func main() {
    clientId := "your-client-id"
    url := fmt.Sprintf("https://api.requestrocket.com/api/clients/%s/invites", clientId)
    
    req, _ := http.NewRequest("GET", url, nil)
    req.Header.Set("Authorization", os.Getenv("USER_TOKEN"))

    client := &http.Client{}
    resp, _ := client.Do(req)
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    var result Response
    json.Unmarshal(body, &result)
    
    fmt.Printf("Found %d pending invites\n", len(result.Invites))
}
import java.net.http.*;
import java.net.URI;
import com.google.gson.*;

public class ListInvites {
    public static void main(String[] args) throws Exception {
        String clientId = "your-client-id";
        
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.requestrocket.com/api/clients/" + clientId + "/invites"))
            .header("Authorization", System.getenv("USER_TOKEN"))
            .GET()
            .build();

        HttpResponse<String> response = client.send(request, 
            HttpResponse.BodyHandlers.ofString());

        JsonObject json = JsonParser.parseString(response.body()).getAsJsonObject();
        JsonArray invites = json.getAsJsonArray("invites");
        System.out.println("Found " + invites.size() + " pending invites");
    }
}
curl -X GET "https://api.requestrocket.com/api/clients/${CLIENT_ID}/invites" \
  -H "Authorization: ${USER_TOKEN}"

Create Invite

Send an invitation to join your organisation.

Request

POST /api/clients/{clientId}/invites HTTP/1.1
Host: api.requestrocket.com
Authorization: {user_token}
Content-Type: application/json

{
  "email": "colleague@example.com",
  "role": "user"
}

Response

{
  "invites": [
    {
      "clientName": "Acme Corporation",
      "inviteId": "95c594c9-8a98-4aeb-ae3c-bad251bc3ce2",
      "pKey": "INVITATION",
      "roles": [
        "user"
      ],
      "userEmail": "colleague@example.com",
      "parentId": "550e8400-e29b-41d4-a716-446655440000",
      "TTL": 1770288917,
      "sKey": "95c594c9-8a98-4aeb-ae3c-bad251bc3ce2"
    }
  ],
  "message": "Success"
}

Invites expire after 7 days (indicated by the TTL field). The recipient will receive an email with a link to accept the invitation.

Example

const response = await fetch(
  `https://api.requestrocket.com/api/clients/${clientId}/invites`,
  {
    method: 'POST',
    headers: {
      'Authorization': process.env.USER_TOKEN,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      email: 'colleague@example.com',
      role: 'user'
    })
  }
);

const data = await response.json();
console.log('Invite sent:', data.invites[0]);
import requests
import os

client_id = "your-client-id"

response = requests.post(
    f'https://api.requestrocket.com/api/clients/{client_id}/invites',
    headers={'Authorization': os.getenv('USER_TOKEN')},
    json={
        'email': 'colleague@example.com',
        'role': 'user'
    }
)

data = response.json()
print(f"Invite sent to: {data['invites'][0]['userEmail']}")
package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "os"
)

type InviteRequest struct {
    Email string `json:"email"`
    Role  string `json:"role"`
}

func main() {
    clientId := "your-client-id"

    requestBody, _ := json.Marshal(InviteRequest{
        Email: "colleague@example.com",
        Role:  "user",
    })

    url := fmt.Sprintf("https://api.requestrocket.com/api/clients/%s/invites", clientId)
    req, _ := http.NewRequest("POST", url, bytes.NewBuffer(requestBody))
    req.Header.Set("Authorization", os.Getenv("USER_TOKEN"))
    req.Header.Set("Content-Type", "application/json")

    client := &http.Client{}
    resp, _ := client.Do(req)
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))
}
import java.net.http.*;
import java.net.URI;
import com.google.gson.*;

public class CreateInvite {
    public static void main(String[] args) throws Exception {
        String clientId = "your-client-id";
        String json = "{"
            + "\"email\": \"colleague@example.com\","
            + "\"role\": \"user\""
            + "}";

        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.requestrocket.com/api/clients/" + clientId + "/invites"))
            .header("Authorization", System.getenv("USER_TOKEN"))
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(json))
            .build();

        HttpResponse<String> response = client.send(request,
            HttpResponse.BodyHandlers.ofString());

        System.out.println(response.body());
    }
}
curl -X POST "https://api.requestrocket.com/api/clients/${CLIENT_ID}/invites" \
  -H "Authorization: ${USER_TOKEN}" \
  -H "Content-Type: application/json" \
  -d '{
    "email": "colleague@example.com",
    "role": "user"
  }'

Delete Invite

Cancel a pending invitation.

Request

DELETE /api/clients/{clientId}/invites/{inviteId} HTTP/1.1
Host: api.requestrocket.com
Authorization: {user_token}

Response

{
  "message": "Invite cancelled successfully"
}

Example

const response = await fetch(
  `https://api.requestrocket.com/api/clients/${clientId}/invites/${inviteId}`,
  {
    method: 'DELETE',
    headers: {
      'Authorization': process.env.USER_TOKEN
    }
  }
);

const data = await response.json();
console.log(data.message);
import requests
import os

client_id = "your-client-id"
invite_id = "invite-id"

response = requests.delete(
    f'https://api.requestrocket.com/api/clients/{client_id}/invites/{invite_id}',
    headers={'Authorization': os.getenv('USER_TOKEN')}
)

data = response.json()
print(data['message'])
package main

import (
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "os"
)

type Response struct {
    Message string `json:"message"`
}

func main() {
    clientId := "your-client-id"
    inviteId := "invite-id"
    
    url := fmt.Sprintf("https://api.requestrocket.com/api/clients/%s/invites/%s", clientId, inviteId)
    req, _ := http.NewRequest("DELETE", url, nil)
    req.Header.Set("Authorization", os.Getenv("USER_TOKEN"))

    client := &http.Client{}
    resp, _ := client.Do(req)
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    var result Response
    json.Unmarshal(body, &result)
    
    fmt.Println(result.Message)
}
import java.net.http.*;
import java.net.URI;
import com.google.gson.*;

public class DeleteInvite {
    public static void main(String[] args) throws Exception {
        String clientId = "your-client-id";
        String inviteId = "invite-id";
        
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.requestrocket.com/api/clients/" + clientId + "/invites/" + inviteId))
            .header("Authorization", System.getenv("USER_TOKEN"))
            .DELETE()
            .build();

        HttpResponse<String> response = client.send(request, 
            HttpResponse.BodyHandlers.ofString());

        JsonObject json = JsonParser.parseString(response.body()).getAsJsonObject();
        System.out.println(json.get("message").getAsString());
    }
}
curl -X DELETE "https://api.requestrocket.com/api/clients/${CLIENT_ID}/invites/${INVITE_ID}" \
  -H "Authorization: ${USER_TOKEN}"

User Invites

List User Invites

Get all invitations sent to a specific user.

Request

GET /api/users/{userId}/invites HTTP/1.1
Host: api.requestrocket.com
Authorization: {user_token}

Response

{
  "invites": [
    {
      "clientName": "Acme Corporation",
      "inviteId": "95c594c9-8a98-4aeb-ae3c-bad251bc3ce2",
      "pKey": "INVITATION",
      "roles": [
        "user"
      ],
      "userEmail": "user@example.com",
      "parentId": "550e8400-e29b-41d4-a716-446655440000",
      "TTL": 1770288917,
      "sKey": "95c594c9-8a98-4aeb-ae3c-bad251bc3ce2"
    }
  ],
  "message": "Success"
}

Example

const response = await fetch(
  `https://api.requestrocket.com/api/users/${userId}/invites`,
  {
    headers: {
      'Authorization': process.env.USER_TOKEN
    }
  }
);

const data = await response.json();
console.log('Your invites:', data.invites);
data.invites.forEach(invite => {
  console.log(`Invited to: ${invite.clientName} as ${invite.roles.join(', ')}`);
});
import requests
import os

user_id = "your-user-id"

response = requests.get(
    f'https://api.requestrocket.com/api/users/{user_id}/invites',
    headers={'Authorization': os.getenv('USER_TOKEN')}
)

data = response.json()
for invite in data['invites']:
    print(f"Invited to: {invite['clientName']} as {', '.join(invite['roles'])}")
package main

import (
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "os"
)

type Invite struct {
    ClientName string   `json:"clientName"`
    InviteId   string   `json:"inviteId"`
    PKey       string   `json:"pKey"`
    Roles      []string `json:"roles"`
    UserEmail  string   `json:"userEmail"`
    ParentId   string   `json:"parentId"`
    TTL        int64    `json:"TTL"`
    SKey       string   `json:"sKey"`
}

type Response struct {
    Invites []Invite `json:"invites"`
    Message string   `json:"message"`
}

func main() {
    userId := "your-user-id"
    url := fmt.Sprintf("https://api.requestrocket.com/api/users/%s/invites", userId)
    
    req, _ := http.NewRequest("GET", url, nil)
    req.Header.Set("Authorization", os.Getenv("USER_TOKEN"))

    client := &http.Client{}
    resp, _ := client.Do(req)
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    var result Response
    json.Unmarshal(body, &result)
    
    for _, invite := range result.Invites {
        fmt.Printf("Invited to: %s as %v\n", invite.ClientName, invite.Roles)
    }
}
import java.net.http.*;
import java.net.URI;
import com.google.gson.*;

public class ListUserInvites {
    public static void main(String[] args) throws Exception {
        String userId = "your-user-id";
        
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.requestrocket.com/api/users/" + userId + "/invites"))
            .header("Authorization", System.getenv("USER_TOKEN"))
            .GET()
            .build();

        HttpResponse<String> response = client.send(request, 
            HttpResponse.BodyHandlers.ofString());

        JsonObject json = JsonParser.parseString(response.body()).getAsJsonObject();
        JsonArray invites = json.getAsJsonArray("invites");
        
        for (int i = 0; i < invites.size(); i++) {
            JsonObject invite = invites.get(i).getAsJsonObject();
            JsonArray roles = invite.getAsJsonArray("roles");
            System.out.println("Invited to: " + invite.get("clientName").getAsString() + 
                " as " + roles);
        }
    }
}
curl -X GET "https://api.requestrocket.com/api/users/${USER_ID}/invites" \
  -H "Authorization: ${USER_TOKEN}"

Accept Invite

Accept an invitation to join an organisation.

Request

PUT /api/users/{userId}/invites/{inviteId} HTTP/1.1
Host: api.requestrocket.com
Authorization: {user_token}
Content-Type: application/json

{
  "acceptInvite": true
}

Response

{
  "message": "Invite accepted successfully"
}

Example

const response = await fetch(
  `https://api.requestrocket.com/api/users/${userId}/invites/${inviteId}`,
  {
    method: 'PUT',
    headers: {
      'Authorization': process.env.USER_TOKEN,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      acceptInvite: true
    })
  }
);

const data = await response.json();
console.log(data.message);
import requests
import os

user_id = "your-user-id"
invite_id = "invite-id"

response = requests.put(
    f'https://api.requestrocket.com/api/users/{user_id}/invites/{invite_id}',
    headers={'Authorization': os.getenv('USER_TOKEN')},
    json={'acceptInvite': True}
)

data = response.json()
print(data['message'])
package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "os"
)

type AcceptInviteRequest struct {
    AcceptInvite bool `json:"acceptInvite"`
}

type Response struct {
    Message string `json:"message"`
}

func main() {
    userId := "your-user-id"
    inviteId := "invite-id"
    
    requestBody, _ := json.Marshal(AcceptInviteRequest{
        AcceptInvite: true,
    })

    url := fmt.Sprintf("https://api.requestrocket.com/api/users/%s/invites/%s", userId, inviteId)
    req, _ := http.NewRequest("PUT", url, bytes.NewBuffer(requestBody))
    req.Header.Set("Authorization", os.Getenv("USER_TOKEN"))
    req.Header.Set("Content-Type", "application/json")

    client := &http.Client{}
    resp, _ := client.Do(req)
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    var result Response
    json.Unmarshal(body, &result)
    
    fmt.Println(result.Message)
}
import java.net.http.*;
import java.net.URI;
import com.google.gson.*;

public class AcceptInvite {
    public static void main(String[] args) throws Exception {
        String userId = "your-user-id";
        String inviteId = "invite-id";
        String json = "{\"acceptInvite\": true}";
        
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.requestrocket.com/api/users/" + userId + "/invites/" + inviteId))
            .header("Authorization", System.getenv("USER_TOKEN"))
            .header("Content-Type", "application/json")
            .PUT(HttpRequest.BodyPublishers.ofString(json))
            .build();

        HttpResponse<String> response = client.send(request, 
            HttpResponse.BodyHandlers.ofString());

        JsonObject jsonResponse = JsonParser.parseString(response.body()).getAsJsonObject();
        System.out.println(jsonResponse.get("message").getAsString());
    }
}
curl -X PUT "https://api.requestrocket.com/api/users/${USER_ID}/invites/${INVITE_ID}" \
  -H "Authorization: ${USER_TOKEN}" \
  -H "Content-Type: application/json" \
  -d '{
    "acceptInvite": true
  }'

Reject Invite

Decline an invitation to join an organisation.

Request

DELETE /api/users/{userId}/invites/{inviteId} HTTP/1.1
Host: api.requestrocket.com
Authorization: {user_token}

Response

{
  "message": "Invite rejected successfully"
}

Example

const response = await fetch(
  `https://api.requestrocket.com/api/users/${userId}/invites/${inviteId}`,
  {
    method: 'DELETE',
    headers: {
      'Authorization': process.env.USER_TOKEN
    }
  }
);

const data = await response.json();
console.log(data.message);
import requests
import os

user_id = "your-user-id"
invite_id = "invite-id"

response = requests.delete(
    f'https://api.requestrocket.com/api/users/{user_id}/invites/{invite_id}',
    headers={'Authorization': os.getenv('USER_TOKEN')}
)

data = response.json()
print(data['message'])
package main

import (
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "os"
)

type Response struct {
    Message string `json:"message"`
}

func main() {
    userId := "your-user-id"
    inviteId := "invite-id"
    
    url := fmt.Sprintf("https://api.requestrocket.com/api/users/%s/invites/%s", userId, inviteId)
    req, _ := http.NewRequest("DELETE", url, nil)
    req.Header.Set("Authorization", os.Getenv("USER_TOKEN"))

    client := &http.Client{}
    resp, _ := client.Do(req)
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    var result Response
    json.Unmarshal(body, &result)
    
    fmt.Println(result.Message)
}
import java.net.http.*;
import java.net.URI;
import com.google.gson.*;

public class RejectInvite {
    public static void main(String[] args) throws Exception {
        String userId = "your-user-id";
        String inviteId = "invite-id";
        
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.requestrocket.com/api/users/" + userId + "/invites/" + inviteId))
            .header("Authorization", System.getenv("USER_TOKEN"))
            .DELETE()
            .build();

        HttpResponse<String> response = client.send(request, 
            HttpResponse.BodyHandlers.ofString());

        JsonObject json = JsonParser.parseString(response.body()).getAsJsonObject();
        System.out.println(json.get("message").getAsString());
    }
}
curl -X DELETE "https://api.requestrocket.com/api/users/${USER_ID}/invites/${INVITE_ID}" \
  -H "Authorization: ${USER_TOKEN}"

Next Steps

Organisations Guide

Learn more about team management

Personal Settings

Manage your user account

Client Integration

Integrate RequestRocket into your app

Members API

Manage client (organisation) members and their roles

Users API

Manage your user profile

On this page

Invites API
Client Invite Endpoints
User Invite Endpoints
List Client Invites
Request
Response
Example
Create Invite
Request
Response
Example
Delete Invite
Request
Response
Example
User Invites
List User Invites
Request
Response
Example
Accept Invite
Request
Response
Example
Reject Invite
Request
Response
Example
Next Steps