Phase Two Admin REST API

https://phasetwo.io/api/
Admin
Phase Two Admin REST API is a REST API reference for Phase Two Keycloak custom resources that...
Tokens:110,362
Snippets:392
Trust Score:8.4
Update:10 months ago
Show doc for...
Tokens:
Raw
### Get Invitations for Authenticated User (Python)

Source: https://phasetwo.io/api/invitations

Python example using the `requests` library to get user invitations. It constructs a GET request with the necessary headers for authentication and content type.

```python
import requests

def get_invitations(realm, token):
    url = f"https://app.phasetwo.io/realms/{realm}/orgs/me/invitations"
    headers = {
        "Accept": "application/json",
        "Authorization": f"Bearer {token}"
    }

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

    if response.status_code == 200:
        return response.json()
    else:
        response.raise_for_status() # Raise an exception for bad status codes

# Example usage:
# realm = "your-realm"
# token = "your-token"
# invitations = get_invitations(realm, token)
# print(invitations)
```

--------------------------------

### Get Identity Provider by Alias - C# Example

Source: https://phasetwo.io/api/get-idp

An example in C# showing how to use HttpClient to fetch an identity provider's details. It configures the request with the correct URL, sets the 'Accept' and 'Authorization' headers, and handles the successful response.

```csharp
var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "https://app.phasetwo.io/realms/:realm/orgs/:orgId/idps/:alias");
request.Headers.Add("Accept", "application/json");
request.Headers.Add("Authorization", "Bearer <token>");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());
```

--------------------------------

### Get Invitations for Authenticated User (Go)

Source: https://phasetwo.io/api/invitations

Go language example for calling the Phase Two API to get user invitations. It utilizes the `net/http` package to create a GET request, set headers, and process the response.

```go
package main

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

func main() {
	client := &http.Client{}

	req, err := http.NewRequest("GET", "https://app.phasetwo.io/realms/:realm/orgs/me/invitations", nil)
	if err != nil {
		fmt.Println(err)
		return
	}

	req.Header.Add("Accept", "application/json")
	req.Header.Add("Authorization", "Bearer <token>")

	resp, err := client.Do(req)
	if err != nil {
		fmt.Println(err)
		return
	}

	defer resp.Body.Close()

	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		fmt.Println(err)
		return
	}

	fmt.Println(string(body))
}
```

--------------------------------

### Get Invitations for Authenticated User (Java)

Source: https://phasetwo.io/api/invitations

Java code example demonstrating how to fetch user invitations using the `HttpClient` class. It sets up a GET request with appropriate headers for content type and authorization.

```java
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.io.IOException;

public class GetInvitations {

    public static void main(String[] args) throws IOException, InterruptedException {

        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
                .uri(java.net.URI.create("https://app.phasetwo.io/realms/:realm/orgs/me/invitations"))
                .header("Accept", "application/json")
                .header("Authorization", "Bearer <token>")
                .GET()
                .build();

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

        System.out.println(response.statusCode());
        System.out.println(response.body());
    }
}
```

--------------------------------

### Get Invitations for Authenticated User (Kotlin)

Source: https://phasetwo.io/api/invitations

Kotlin code example using OkHttp to make a GET request for user invitations. It configures the request with the API endpoint and necessary headers.

```kotlin
import okhttp3.OkHttpClient
import okhttp3.Request
import java.io.IOException

fun getInvitations(realm: String, token: String) {
    val client = OkHttpClient()
    val request = Request.Builder()
        .url("https://app.phasetwo.io/realms/$realm/orgs/me/invitations")
        .get()
        .addHeader("Accept", "application/json")
        .addHeader("Authorization", "Bearer $token")
        .build()

    try {
        client.newCall(request).execute().use { response ->
            if (!response.isSuccessful) throw IOException("Unexpected code $response")

            val responseBody = response.body?.string()
            println(responseBody)
        }
    } catch (e: IOException) {
        e.printStackTrace()
    }
}

// Example usage:
// getInvitations("your-realm", "your-token")
```

--------------------------------

### Get Invitations for Authenticated User (C#)

Source: https://phasetwo.io/api/invitations

C# code example using HttpClient to fetch user invitations from the Phase Two API. It constructs an HTTP GET request, sets necessary headers (Accept, Authorization), sends the request, and prints the successful response content.

```csharp
var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "https://app.phasetwo.io/realms/:realm/orgs/me/invitations");
request.Headers.Add("Accept", "application/json");
request.Headers.Add("Authorization", "Bearer <token>");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());
```

--------------------------------

### Get Webhook Send by ID (C# HttpClient Example)

Source: https://phasetwo.io/api/get-webhook-send-by-id

Example demonstrating how to fetch a webhook send event using C#'s HttpClient. This code snippet shows how to construct the GET request, set necessary headers (Accept and Authorization), send the request, and process the response. Ensure you replace '<token>' with a valid access token.

```csharp
var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "https://app.phasetwo.io/realms/:realm/webhooks/:webhookId/sends/:sendId");
request.Headers.Add("Accept", "application/json");
request.Headers.Add("Authorization", "Bearer <token>");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());
```

--------------------------------

### Get Invitations for Authenticated User (Rust)

Source: https://phasetwo.io/api/invitations

Rust code example using the `reqwest` crate to make an HTTP GET request for user invitations. It sets the URL and headers, including the Bearer token for authorization.

```rust
use reqwest::header;

#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
    let realm = "your-realm";
    let token = "your-token";
    let url = format!("https://app.phasetwo.io/realms/{}/orgs/me/invitations", realm);

    let client = reqwest::Client::new();
    let response = client.get(&url)
        .header(header::ACCEPT, "application/json")
        .header(header::AUTHORIZATION, format!("Bearer {}", token))
        .send()
        .await?;

    let body = response.text().await?;
    println!("{}", body);

    Ok(())
}

```

--------------------------------

### Get Invitations for Authenticated User (Node.js)

Source: https://phasetwo.io/api/invitations

Node.js code example using the built-in 'https' module to fetch user invitations. It demonstrates setting up the request options, sending the request, and handling the response data.

```javascript
const https = require('https');

function getInvitations(realm, token) {
  const options = {
    hostname: 'app.phasetwo.io',
    port: 443,
    path: `/realms/${realm}/orgs/me/invitations`,
    method: 'GET',
    headers: {
      'Accept': 'application/json',
      'Authorization': `Bearer ${token}`
    }
  };

  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', (error) => {
    console.error(error);
  });

  req.end();
}

// Example usage:
// getInvitations('your-realm', 'your-token');
```

--------------------------------

### Get Realm Attributes (Python)

Source: https://phasetwo.io/api/get-realm-attributes

A Python example using the 'requests' library to get realm attributes. It constructs a GET request with necessary headers like Authorization and Accept, and handles the JSON response.

```python
import requests

url = "https://app.phasetwo.io/realms/:realm/attributes"
headers = {
    "Authorization": "Bearer <token>",
    "Accept": "application/json"
}

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

if response.status_code == 200:
    print(response.json())
else:
    print(f"Error: {response.status_code}")
    print(response.text)
```

--------------------------------

### Get Organization Roles (Rust)

Source: https://phasetwo.io/api/get-organization-roles

Rust example using the reqwest library to fetch organization roles. It demonstrates making a GET request with the Authorization and Accept headers.

```rust
use reqwest::blocking::Client;
use reqwest::header::{ACCEPT, AUTHORIZATION, HeaderValue};

fn main() -> Result<(), reqwest::Error> {
    let client = Client::new();
    let url = "https://app.phasetwo.io/realms/:realm/orgs/:orgId/roles";

    let resp = client.get(url)
        .header(AUTHORIZATION, HeaderValue::from_static("Bearer <token>"))
        .header(ACCEPT, HeaderValue::from_static("application/json"))
        .send()?;

    let body = resp.text()?;
    println!("{}", body);
    Ok(())
}

```

--------------------------------

### Get Invitations for Authenticated User (Swift)

Source: https://phasetwo.io/api/invitations

Swift code example using URLSession to fetch user invitations from the Phase Two API. It constructs a URLRequest with the appropriate method and headers.

```swift
import Foundation

func getInvitations(realm: String, token: String, completion: @escaping (Result<[String: Any], Error>) -> Void) {
    guard let url = URL(string: "https://app.phasetwo.io/realms/(realm)/orgs/me/invitations") else {
        completion(.failure(NSError(domain: "", code: -1, userInfo: [NSLocalizedDescriptionKey: "Invalid URL"])))
        return
    }

    var request = URLRequest(url: url)
    request.httpMethod = "GET"
    request.setValue("application/json", forHTTPHeaderField: "Accept")
    request.setValue("Bearer (token)", forHTTPHeaderField: "Authorization")

    URLSession.shared.dataTask(with: request) { data, response, error in
        if let error = error {
            completion(.failure(error))
            return
        }

        guard let httpResponse = response as? HTTPURLResponse, httpResponse.statusCode == 200 else {
            completion(.failure(NSError(domain: "", code: -2, userInfo: [NSLocalizedDescriptionKey: "Bad response"])))
            return
        }

        if let data = data {
            do {
                if let json = try JSONSerialization.jsonObject(with: data, options: []) as? [String: Any] {
                    completion(.success(json))
                } else {
                    completion(.failure(NSError(domain: "", code: -3, userInfo: [NSLocalizedDescriptionKey: "Invalid JSON"])))
                }
            } catch {
                completion(.failure(error))
            }
        }
    }.resume()
}

// Example usage:
// getInvitations(realm: "your-realm", token: "your-token") { result in
//     switch result {
//     case .success(let data):
//         print(data)
//     case .failure(let error):
//         print(error.localizedDescription)
//     }
// }
```

--------------------------------

### Get Organization Invitation Count in Go

Source: https://phasetwo.io/api/get-organization-invitation-count

An example in Go for fetching the organization invitation count. It utilizes the standard library's `net/http` package to construct and send the GET request with appropriate headers.

```go
package main

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

func main() {
	url := "https://app.phasetwo.io/realms/:realm/orgs/:orgId/invitations/count"
	method := "GET"

	client := &http.Client {}
	req, err := http.NewRequest(method, url, nil)
	if err != nil {
		fmt.Println(err)
		return
	}

	req.Header.Add("Accept", "application/json")
	req.Header.Add("Authorization", "Bearer <token>")

	res, err := client.Do(req)
	if err != nil {
		fmt.Println(err)
		return
	}
	defer res.Body.Close()

	body, err := ioutil.ReadAll(res.Body)
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println(string(body))
}
```

--------------------------------

### Get Invitations for Authenticated User (Curl)

Source: https://phasetwo.io/api/invitations

Example using curl to retrieve user invitations from the Phase Two API. This command demonstrates how to make a GET request to the specified endpoint, including the necessary Authorization header with a Bearer token.

```shell
curl -X GET "https://app.phasetwo.io/realms/:realm/orgs/me/invitations" \
  -H "Accept: application/json" \
  -H "Authorization: Bearer <token>"
```

--------------------------------

### Get Organization Count - C# Example

Source: https://phasetwo.io/api/get-organizations-count

This C# code snippet demonstrates how to make a GET request to the organization count endpoint using HttpClient. It includes setting the necessary headers for accept and authorization. The response content is read and printed to the console.

```csharp
var client = new HttpClient();  
var request = new HttpRequestMessage(HttpMethod.Get, "https://app.phasetwo.io/realms/:realm/orgs/count");  
request.Headers.Add("Accept", "application/json");  
request.Headers.Add("Authorization", "Bearer <token>");  
var response = await client.SendAsync(request);  
response.EnsureSuccessStatusCode();  
Console.WriteLine(await response.Content.ReadAsStringAsync());  
```

--------------------------------

### Get Organization Invitation Count in Python

Source: https://phasetwo.io/api/get-organization-invitation-count

A Python example using the 'requests' library to call the API. It shows how to construct the URL, add the necessary headers for authentication and content type, and print the response JSON.

```python
import requests

def get_invitation_count(realm, org_id, token):
    url = f"https://app.phasetwo.io/realms/{realm}/orgs/{org_id}/invitations/count"
    headers = {
        'Accept': 'application/json',
        'Authorization': f'Bearer {token}'
    }
    
    response = requests.get(url, headers=headers)
    
    if response.status_code == 200:
        return response.json()
    else:
        print(f"Error: {response.status_code}")
        return None

# Example usage:
# realm_name = ":realm"
# organization_id = ":orgId"
# access_token = "<token>"
# count = get_invitation_count(realm_name, organization_id, access_token)
# if count:
#     print(f"Invitation count: {count}")

```

--------------------------------

### Get Role by Name API Endpoint and Example

Source: https://phasetwo.io/api/get-organization-role

This snippet details the GET request to retrieve a role by its name for a given organization within a realm. It specifies the endpoint URL, required path parameters (realm, orgId, name), and provides an example JSON response schema. Authorization is handled via a Bearer token.

```http
GET https://app.phasetwo.io/realms/:realm/orgs/:orgId/roles/:name
```

```json
{
  "id": "string",
  "name": "string",
  "description": "string"
}
```

```http
Authorization: Bearer <token>
```

--------------------------------

### Get Identity Provider Mapper by ID (Shell)

Source: https://phasetwo.io/api/get-idp-mapper

A shell script example using 'curl' to get an identity provider mapper by its ID. It constructs the GET request and includes the 'Authorization' and 'Accept' headers.

```shell
REALM="your_realm"
ORG_ID="your_org_id"
ALIAS="your_alias"
MAPPER_ID="your_mapper_id"
TOKEN="your_token"

curl -X GET "https://app.phasetwo.io/realms/${REALM}/orgs/${ORG_ID}/idps/${ALIAS}/mappers/${MAPPER_ID}" \
     -H "Authorization: Bearer ${TOKEN}" \
     -H "Accept: application/json"
```

--------------------------------

### Get Identity Provider Mapper by ID (Go)

Source: https://phasetwo.io/api/get-idp-mapper

Example in Go to get an identity provider mapper by ID. It utilizes the standard 'net/http' package to make a GET request, setting the 'Authorization' and 'Accept' headers.

```go
package main

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

func main() {
	url := "https://app.phasetwo.io/realms/:realm/orgs/:orgId/idps/:alias/mappers/:id"
	client := &http.Client{}

	req, err := http.NewRequest("GET", url, nil)
	if err != nil {
		fmt.Println(err)
		return
	}

	req.Header.Add("Authorization", "Bearer <token>")
	req.Header.Add("Accept", "application/json")

	res, err := client.Do(req)
	if err != nil {
		fmt.Println(err)
		return
	}
	defer res.Body.Close()

	body, err := ioutil.ReadAll(res.Body)
	if err != nil {
		fmt.Println(err)
		return
	}

	fmt.Println(string(body))
}
```

--------------------------------

### Get Organization by ID - C# HttpClient Example

Source: https://phasetwo.io/api/get-organization-by-id

Example using C# HttpClient to call the Phase Two API for retrieving organization details. It sets the HTTP method, URL, and necessary headers like Accept and Authorization.

```csharp
var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "https://app.phasetwo.io/realms/:realm/orgs/:orgId");
request.Headers.Add("Accept", "application/json");
request.Headers.Add("Authorization", "Bearer <token>");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());
```

--------------------------------

### Start Domain Verification API Request (C#)

Source: https://phasetwo.io/api/verify-domain

C# implementation using HttpClient to send a POST request for domain verification. It sets the Authorization header and handles the response. Ensure you replace '<token>' with your actual access token.

```csharp
var client = new HttpClient();  
var request = new HttpRequestMessage(HttpMethod.Post, "https://app.phasetwo.io/realms/:realm/orgs/:orgId/domains/:domainName/verify");  
request.Headers.Add("Authorization", "Bearer <token>");  
var response = await client.SendAsync(request);  
response.EnsureSuccessStatusCode();  
Console.WriteLine(await response.Content.ReadAsStringAsync());  
```

--------------------------------

### Get Organization Roles (Swift)

Source: https://phasetwo.io/api/get-organization-roles

Swift code example using URLSession to fetch organization roles. It configures a GET request with the necessary Authorization and Accept headers.

```swift
import Foundation

let url = URL(string: "https://app.phasetwo.io/realms/:realm/orgs/:orgId/roles")!
var request = URLRequest(url: url)
request.httpMethod = "GET"
request.setValue("application/json", forHTTPHeaderField: "Accept")
request.setValue("Bearer <token>", forHTTPHeaderField: "Authorization")

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    if let error = error {
        print("Error: \(error)\n")
        return
    }
    if let data = data, let dataString = String(data: data, encoding: .utf8) {
        print("Response: \(dataString)\n")
    }
}

task.resume()
```

--------------------------------

### Client Credentials Grant Example

Source: https://phasetwo.io/api/phase-two-admin-rest-api

Example of obtaining an access token using the client credentials grant type for authentication.

```APIDOC
## POST /auth/realms/{realm}/protocol/openid-connect/token

### Description
Obtains an access token using the client credentials grant type. This is often used for service-to-service authentication.

### Method
POST

### Endpoint
`/auth/realms/{realm}/protocol/openid-connect/token`

### Parameters
#### Query Parameters
- **grant_type** (string) - Required - Specifies the grant type, must be `client_credentials`.
- **client_id** (string) - Required - The ID of the client.
- **client_secret** (string) - Required - The secret of the client.

### Request Example
```
POST /auth/realms/test-realm/protocol/openid-connect/token
Host: app.phasetwo.io
Accept: application/json
Content-type: application/x-www-form-urlencoded

grant_type=client_credentials&client_id=admin-cli&client_secret=fd649804-3a74-4d69-acaa-8f065c6b7da1
```

### Response
#### Success Response (200)
- **access_token** (string) - The obtained access token.
- **expires_in** (integer) - The lifetime in seconds of the access token.
- **refresh_expires_in** (integer) - The lifetime in seconds of the refresh token.
- **refresh_token** (string) - The refresh token.
- **token_type** (string) - The type of the token (e.g., Bearer).
- **not_before_policy** (integer) - The not before policy.
- **session_state** (string) - The session state.
- **scope** (string) - The scope of the token.
```

--------------------------------

### Get Organization Roles (Ruby)

Source: https://phasetwo.io/api/get-organization-roles

Ruby example using the Net::HTTP library to make a GET request for organization roles. It sets the Authorization and Accept headers.

```ruby
require 'net/http'
require 'uri'

uri = URI.parse('https://app.phasetwo.io/realms/:realm/orgs/:orgId/roles')

Net::HTTP.start(uri.host, uri.port, use_ssl: true) do |http|
  request = Net::HTTP::Get.new(uri)
  request['Authorization'] = 'Bearer <token>'
  request['Accept'] = 'application/json'

  response = http.request(request)
  puts response.body
end
```

--------------------------------

### Get Organization Roles (PHP)

Source: https://phasetwo.io/api/get-organization-roles

PHP code example using cURL to fetch organization roles. It configures a GET request, setting the Authorization and Accept headers.

```php
<?php

$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, 'https://app.phasetwo.io/realms/:realm/orgs/:orgId/roles');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');

curl_setopt($ch, CURLOPT_HTTPHEADER, array(
    'Authorization: Bearer <token>',
    'Accept: application/json'
));

$response = curl_exec($ch);

if (curl_errno($ch)) {
    echo 'Error:' . curl_error($ch);
}

curl_close($ch);

echo $response;

?>
```

--------------------------------

### Create Webhook - JavaScript Fetch API

Source: https://phasetwo.io/api/create-webhook

Example of creating a new webhook using the JavaScript Fetch API. This code demonstrates how to make a POST request to the webhook endpoint, including setting the Authorization header and sending the JSON body.

```javascript
fetch('https://app.phasetwo.io/realms/:realm/webhooks', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer <token>',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    "attributes": {},
    "id": "string",
    "enabled": true,
    "url": "string",
    "secret": "string",
    "createdBy": "string",
    "createdAt": 0,
    "realm": "string",
    "eventTypes": [
      "string"
    ]
  })
})
.then(response => {
  if (!response.ok) {
    throw new Error('Network response was not ok');
  }
  return response.json();
})
.then(data => console.log(data))
.catch(error => console.error('Error:', error));

```

--------------------------------

### Get Organization Invitation Count in JavaScript (Fetch API)

Source: https://phasetwo.io/api/get-organization-invitation-count

A JavaScript example using the Fetch API to get the organization invitation count. It shows how to configure the GET request with necessary headers and process the JSON response.

```javascript
async function getInvitationCount(realm, orgId, token) {
  const url = `https://app.phasetwo.io/realms/${realm}/orgs/${orgId}/invitations/count`;
  const response = await fetch(url, {
    method: 'GET',
    headers: {
      'Accept': 'application/json',
      'Authorization': `Bearer ${token}`
    }
  });

  if (!response.ok) {
    throw new Error(`HTTP error! status: ${response.status}`);
  }

  const data = await response.json();
  console.log(data);
  return data;
}

```

--------------------------------

### Create Magic Link with Go

Source: https://phasetwo.io/api/create-magic-link

This Go code snippet shows how to create a magic link by sending a POST request. It utilizes the standard library's `net/http` package.

```go
package main

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

func main() {
	url := "https://app.phasetwo.io/realms/:realm/magic-link"

	requestBody := []byte(`{
		"email": "string",
		"client_id": "string",
		"redirect_uri": "string",
		"expiration_seconds": 0,
		"force_create": true,
		"send_email": true,
		"update_profile": true,
		"update_password": true,
		"scope": "string",
		"nonce": "string",
		"code_challenge": "string",
		"code_challenge_method": "string",
		"remember_me": true,
		"reusable": true
	}`)

	req, err := http.NewRequest("POST", url, bytes.NewBuffer(requestBody))
	if err != nil {
		log.Fatalf("Error creating request: %s", err)
	}

	req.Header.Set("Authorization", "Bearer <token>")
	req.Header.Set("Content-Type", "application/json")

	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		log.Fatalf("Error sending request: %s", err)
	}
	defer resp.Body.Close()

	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		log.Fatalf("Error reading response body: %s", err)
	}

	if resp.StatusCode == http.StatusOK {
		fmt.Printf("Magic Link created: %s\n", string(body))
	} else {
		fmt.Printf("Error creating magic link: %d - %s\n", resp.StatusCode, string(body))
	}
}
```

--------------------------------

### Create Webhook - HTTP Request

Source: https://phasetwo.io/api/create-webhook

A generic HTTP request example for creating a webhook. This demonstrates the necessary components: the POST method, the URL, the Authorization header, and the JSON request body.

```http
POST /realms/:realm/webhooks HTTP/1.1
Host: app.phasetwo.io
Authorization: Bearer <token>
Content-Type: application/json
Content-Length: <length>

{
  "attributes": {},
  "id": "string",
  "enabled": true,
  "url": "string",
  "secret": "string",
  "createdBy": "string",
  "createdAt": 0,
  "realm": "string",
  "eventTypes": [
    "string"
  ]
}
```

--------------------------------

### Get Organization Roles (Python)

Source: https://phasetwo.io/api/get-organization-roles

Python example using the requests library to fetch organization roles. It constructs a GET request and includes the Authorization header with the Bearer token.

```python
import requests

url = "https://app.phasetwo.io/realms/:realm/orgs/:orgId/roles"
headers = {
    "Authorization": "Bearer <token>",
    "Accept": "application/json"
}

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

if response.status_code == 200:
    print(response.json())
else:
    print(f"Error: {response.status_code}")
```

--------------------------------

### Get Organization Roles (Node.js)

Source: https://phasetwo.io/api/get-organization-roles

Node.js example using the built-in https module to make a GET request for organization roles. It configures the request with Authorization and Accept headers.

```javascript
const https = require('https');

const options = {
  hostname: 'app.phasetwo.io',
  port: 443,
  path: '/realms/:realm/orgs/:orgId/roles',
  method: 'GET',
  headers: {
    'Authorization': 'Bearer <token>',
    'Accept': 'application/json'
  }
};

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', (error) => {
  console.error(error);
});

req.end();
```

--------------------------------

### Get Invitations for Authenticated User (Ruby)

Source: https://phasetwo.io/api/invitations

Ruby code snippet using the `Net::HTTP` library to fetch user invitations. It sets up a GET request and includes the required 'Accept' and 'Authorization' headers.

```ruby
require 'net/http'
require 'uri'
require 'json'

def get_invitations(realm, token)
  uri = URI.parse("https://app.phasetwo.io/realms/#{realm}/orgs/me/invitations")
  http = Net::HTTP.new(uri.host, uri.port)
  http.use_ssl = true

  request = Net::HTTP::Get.new(uri.request_uri)
  request['Accept'] = 'application/json'
  request['Authorization'] = "Bearer #{token}"

  response = http.request(request)
  JSON.parse(response.body)
end

# Example usage:
# realm = "your-realm"
# token = "your-token"
# invitations = get_invitations(realm, token)
# puts invitations
```

--------------------------------

### Get Organization Roles (JavaScript)

Source: https://phasetwo.io/api/get-organization-roles

JavaScript example using the fetch API to retrieve organization roles. It makes a GET request and includes the Bearer token in the Authorization header.

```javascript
async function getOrgRoles(realm, orgId, token) {
  const response = await fetch(`https://app.phasetwo.io/realms/${realm}/orgs/${orgId}/roles`, {
    method: 'GET',
    headers: {
      'Authorization': `Bearer ${token}`,
      'Accept': 'application/json'
    }
  });

  if (!response.ok) {
    throw new Error(`HTTP error! status: ${response.status}`);
  }

  const data = await response.json();
  return data;
}

// Example usage:
// getOrgRoles('my-realm', 'my-org-id', 'your-token').then(roles => console.log(roles));
```

--------------------------------

### Create Realm Attribute using various languages

Source: https://phasetwo.io/api/create-realm-attribute

Provides examples for creating a new realm attribute via API requests in multiple programming languages. Each snippet shows how to construct the POST request, including setting the endpoint, headers, and JSON payload. Replace placeholders like '<token>' and ':realm' with your specific values.

```curl
curl --request POST \
  --url https://app.phasetwo.io/realms/:realm/attributes \
  --header 'Authorization: Bearer <token>' \
  --header 'content-type: application/json' \
  --data '{ \n  "name": "string",\n  "value": "string",\n  "realm": "string"\n}'
```

```dart
// Dart example would go here
```

```go
// Go example would go here
```

```http
POST /realms/:realm/attributes HTTP/1.1
Host: app.phasetwo.io
Authorization: Bearer <token>
Content-Type: application/json

{
  "name": "string",
  "value": "string",
  "realm": "string"
}
```

```java
// Java example would go here
```

```javascript
// JavaScript example would go here
```

```kotlin
// Kotlin example would go here
```

```nodejs
// Node.js example would go here
```

```objective-c
// Objective-C example would go here
```

```ocaml
// OCaml example would go here
```

```php
// PHP example would go here
```

```powershell
# PowerShell example would go here
```

```python
# Python example would go here
```

```r
# R example would go here
```

```ruby
# Ruby example would go here
```

```rust
// Rust example would go here
```

```shell
# Shell example would go here
```

```swift
// Swift example would go here
```

--------------------------------

### Switch Organization API Request (Go)

Source: https://phasetwo.io/api/switch-active-organization

This Go program demonstrates how to make a PUT request to the Phase Two API to switch the active organization. It utilizes the `net/http` package and includes setting the Authorization header and the JSON payload. Remember to replace placeholders with your actual credentials and IDs.

```go
package main

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

func main() {
	url := "https://app.phasetwo.io/realms/:realm/users/switch-organization"
	payload := []byte(`{
  "id": "string"
}`) // Replace "string" with your organization ID

	req, err := http.NewRequest("PUT", url, bytes.NewBuffer(payload))
	if err != nil {
		fmt.Println("Error creating request:", err)
		return
	}

	req.Header.Set("Authorization", "Bearer <token>") // Replace <token> with your access token
	req.Header.Set("Content-Type", "application/json")

	client := &http.Client{}
	res, err := client.Do(req)
	if err != nil {
		fmt.Println("Error sending request:", err)
		return
	}
	defer res.Body.Close()

	// Handle response here (e.g., check status code, read body)
	fmt.Println("Status Code:", res.StatusCode)
}
```

--------------------------------

### Get Organization Roles (Java)

Source: https://phasetwo.io/api/get-organization-roles

Java code example using Apache HttpClient to fetch organization roles. It configures a GET request with the necessary Authorization and Accept headers.

```java
import org.apache.http.HttpEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;

import java.io.IOException;

public class GetOrgRoles {

    public static void main(String[] args) throws IOException {
        CloseableHttpClient httpClient = HttpClients.createDefault();
        try {
            HttpGet request = new HttpGet("https://app.phasetwo.io/realms/:realm/orgs/:orgId/roles");
            request.addHeader("Authorization", "Bearer <token>");
            request.addHeader("Accept", "application/json");

            CloseableHttpResponse response = httpClient.execute(request);
            try {
                HttpEntity entity = response.getEntity();
                if (entity != null) {
                    String result = EntityUtils.toString(entity);
                    System.out.println(result);
                }
            } finally {
                response.close();
            }
        } finally {
            httpClient.close();
        }
    }
}
```

--------------------------------

### Get Organization Roles (Curl)

Source: https://phasetwo.io/api/get-organization-roles

Example using curl to fetch organization roles. This command-line snippet demonstrates the GET request and how to include the Bearer token in the Authorization header.

```shell
curl -X GET \
  'https://app.phasetwo.io/realms/:realm/orgs/:orgId/roles' \
  -H 'Authorization: Bearer <token>'
```

--------------------------------

### Create Organization Invitation

Source: https://phasetwo.io/api/category/organization-invitations

Creates an invitation to join a specified organization. Users must register before accepting. Acceptance occurs during login.

```APIDOC
## POST /organizations/{organizationId}/invitations

### Description
Create an invitation to join the specified organization. Requires a user to register with the application (if they don't already have an account) before they can accept the invitation. Acceptance happens during login via a required action.

### Method
POST

### Endpoint
/organizations/{organizationId}/invitations

### Parameters
#### Path Parameters
- **organizationId** (string) - Required - The UUID of the organization to invite a user to.

#### Query Parameters
None

#### Request Body
- **email** (string) - Required - The email address of the user to invite.
- **role** (string) - Optional - The role to assign to the user upon acceptance.

### Request Example
```json
{
  "email": "user@example.com",
  "role": "member"
}
```

### Response
#### Success Response (201)
- **id** (string) - The unique identifier for the invitation.
- **email** (string) - The email address of the invited user.
- **organizationId** (string) - The UUID of the organization.
- **status** (string) - The current status of the invitation (e.g., "pending").

#### Response Example
```json
{
  "id": "inv-uuid-123",
  "email": "user@example.com",
  "organizationId": "org-uuid-456",
  "status": "pending"
}
```
```

--------------------------------

### Get Organization Roles (Go)

Source: https://phasetwo.io/api/get-organization-roles

Go language example for retrieving organization roles. It uses the net/http package to perform a GET request, including the Bearer token in the Authorization header.

```go
package main

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

func main() {
	client := &http.Client{}
	req, err := http.NewRequest("GET", "https://app.phasetwo.io/realms/:realm/orgs/:orgId/roles", nil)
	if err != nil {
		fmt.Println(err)
		return
	}

	req.Header.Add("Authorization", "Bearer <token>")
	req.Header.Add("Accept", "application/json")

	resp, err := client.Do(req)
	if err != nil {
		fmt.Println(err)
		return
	}

defer resp.Body.Close()
	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		fmt.Println(err)
		return
	}

	fmt.Println(string(body))
}
```

--------------------------------

### Import Identity Provider Config (C# HttpClient)

Source: https://phasetwo.io/api/import-idp-json

C# code example using HttpClient to send a POST request to import an identity provider configuration. It sets necessary headers like Accept and Authorization, sends the request, and processes the response.

```csharp
var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://app.phasetwo.io/realms/:realm/orgs/:orgId/idps/import-config");
request.Headers.Add("Accept", "application/json");
request.Headers.Add("Authorization", "Bearer <token>");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());
```

--------------------------------

### Get Identity Providers for Organization (C#)

Source: https://phasetwo.io/api/get-idps

Example using C# HttpClient to fetch identity providers for an organization. This code sends a GET request to the API endpoint with necessary headers for authentication and content type.

```csharp
var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "https://app.phasetwo.io/realms/:realm/orgs/:orgId/idps");
request.Headers.Add("Accept", "application/json");
request.Headers.Add("Authorization", "Bearer <token>");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());
```

--------------------------------

### Create Organization using C# HttpClient

Source: https://phasetwo.io/api/create-organization

This C# code uses the `HttpClient` class to make a POST request to create a new organization. It shows how to set the request method, URL, headers, and JSON content, and handle the response.

```csharp
var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://app.phasetwo.io/realms/:realm/orgs");
request.Headers.Add("Authorization", "Bearer <token>");
var content = new StringContent("{\n  \"id\": \"string\",\n  \"name\": \"string\",\n  \"displayName\": \"string\",\n  \"url\": \"string\",\n  \"realm\": \"string\",\n  \"domains\": [\n    \"string\"\n  ],\n  \"attributes\": {}\n}", null, "application/json");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());
```

--------------------------------

### Password Grant Example

Source: https://phasetwo.io/api/phase-two-admin-rest-api

Example of obtaining an access token using the password grant type for authentication.

```APIDOC
## POST /auth/realms/{realm}/protocol/openid-connect/token

### Description
Obtains an access token using the password grant type. This is typically used for user authentication where the user provides their username and password.

### Method
POST

### Endpoint
`/auth/realms/{realm}/protocol/openid-connect/token`

### Parameters
#### Query Parameters
- **grant_type** (string) - Required - Specifies the grant type, must be `password`.
- **username** (string) - Required - The username of the user.
- **password** (string) - Required - The password of the user.
- **client_id** (string) - Required - The ID of the client.

### Request Example
```
POST /auth/realms/test-realm/protocol/openid-connect/token
Host: app.phasetwo.io
Accept: application/json
Content-type: application/x-www-form-urlencoded

grant_type=password&username=uname@foo.com&password=pwd123AZY&client_id=admin-cli
```

### Response
#### Success Response (200)
- **access_token** (string) - The obtained access token.
- **expires_in** (integer) - The lifetime in seconds of the access token.
- **refresh_expires_in** (integer) - The lifetime in seconds of the refresh token.
- **refresh_token** (string) - The refresh token.
- **token_type** (string) - The type of the token (e.g., Bearer).
- **not_before_policy** (integer) - The not before policy.
- **session_state** (string) - The session state.
- **scope** (string) - The scope of the token.
```

--------------------------------

### Get Organization Invitation Count in Node.js (Axios)

Source: https://phasetwo.io/api/get-organization-invitation-count

Example using the popular Axios library in Node.js to call the API. It demonstrates making a GET request with authorization headers and processing the response.

```javascript
const axios = require('axios');

async function getInvitationCount(realm, orgId, token) {
  const url = `https://app.phasetwo.io/realms/${realm}/orgs/${orgId}/invitations/count`;
  try {
    const response = await axios.get(url, {
      headers: {
        'Accept': 'application/json',
        'Authorization': `Bearer ${token}`
      }
    });
    console.log(response.data);
    return response.data;
  } catch (error) {
    console.error('Error fetching invitation count:', error);
  }
}

```

--------------------------------

### Create Webhook - C# HttpClient

Source: https://phasetwo.io/api/create-webhook

Example of creating a new webhook using C#'s HttpClient. This code sends a POST request to the specified webhook endpoint with the required authorization token and JSON payload. It handles the response and ensures success.

```csharp
var client = new HttpClient();  
var request = new HttpRequestMessage(HttpMethod.Post, "https://app.phasetwo.io/realms/:realm/webhooks");  
request.Headers.Add("Authorization", "Bearer <token>");  
var content = new StringContent("{ \n  \"attributes\": {},\n  \"id\": \"string\",\n  \"enabled\": true,\n  \"url\": \"string\",\n  \"secret\": \"string\",\n  \"createdBy\": \"string\",\n  \"createdAt\": 0,\n  \"realm\": \"string\",\n  \"eventTypes\": [\n    \"string\"\n  ]\n}", null, "application/json");  
request.Content = content;  
var response = await client.SendAsync(request);  
response.EnsureSuccessStatusCode();  
Console.WriteLine(await response.Content.ReadAsStringAsync());  
```

--------------------------------

### Get Organization Invitation Count in Rust (Reqwest)

Source: https://phasetwo.io/api/get-organization-invitation-count

An example in Rust using the 'reqwest' crate to perform the GET request. It shows how to set up the client, request URL, headers, and handle the asynchronous response.

```rust
use reqwest::Error;

#[tokio::main]
async fn main() -> Result<(), Error> {
    let realm = ":realm";
    let org_id = ":orgId";
    let token = "<token>";

    let url = format!("https://app.phasetwo.io/realms/{}/orgs/{}/invitations/count", realm, org_id);

    let client = reqwest::Client::new();
    let response = client.get(&url)
        .header("Accept", "application/json")
        .header("Authorization", &format!("Bearer {}", token))
        .send()
        .await?;

    let body = response.text().await?;
    println!("{}", body);

    Ok(())
}

```

--------------------------------

### Create Magic Link with Rust

Source: https://phasetwo.io/api/create-magic-link

This Rust example uses the 'reqwest' crate to send a POST request for creating a magic link. It shows how to configure headers and the JSON payload.

```rust
use reqwest::header::{AUTHORIZATION, CONTENT_TYPE};
use serde_json::json;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let url = "https://app.phasetwo.io/realms/:realm/magic-link";
    let token = "<token>"; // Replace with your actual token

    let client = reqwest::Client::new();

    let res = client.post(url)
        .header(AUTHORIZATION, format!("Bearer {}", token))
        .header(CONTENT_TYPE, "application/json")
        .json(&json!({
            "email": "string",
            "client_id": "string",
            "redirect_uri": "string",
            "expiration_seconds": 0,
            "force_create": true,
            "send_email": true,
            "update_profile": true,
            "update_password": true,
            "scope": "string",
            "nonce": "string",
            "code_challenge": "string",
            "code_challenge_method": "string",
            "remember_me": true,
            "reusable": true
        }))
        .send()
        .await?;

    if res.status().is_success() {
        let body = res.text().await?;
        println!("Magic Link created: {}", body);
    } else {
        println!("Error creating magic link: {}", res.status());
    }

    Ok(())
}

```

--------------------------------

### Get Identity Provider Mapper by ID (Swift)

Source: https://phasetwo.io/api/get-idp-mapper

Swift code example using URLSession to retrieve an identity provider mapper by ID. This snippet demonstrates creating a GET request with the necessary 'Authorization' and 'Accept' headers.

```swift
import Foundation

func getMapper(realm: String, orgId: String, alias: String, id: String, token: String) {
    guard let url = URL(string: "https://app.phasetwo.io/realms/(realm)/orgs/(orgId)/idps/(alias)/mappers/(id)") else { return }

    var request = URLRequest(url: url)
    request.httpMethod = "GET"
    request.addValue("application/json", forHTTPHeaderField: "Accept")
    request.addValue("Bearer (token)", forHTTPHeaderField: "Authorization")

    URLSession.shared.dataTask(with: request) { data, response, error in
        guard let data = data, error == nil else {
            print(error?.localizedDescription ?? "Unknown error")
            return
        }

        if let httpResponse = response as? HTTPURLResponse, httpResponse.statusCode == 200 {
            if let json = try? JSONSerialization.jsonObject(with: data, options: []) as? [String: Any] {
                print(json)
            }
        } else {
            print("Request failed with status code: \((response as? HTTPURLResponse)?.statusCode ?? -1)")
        }
    }.resume()
}
```

--------------------------------

### Client Credentials Grant Example for Token Endpoint

Source: https://phasetwo.io/api/phase-two-admin-rest-api

Demonstrates how to obtain an access token using the client credentials grant type. This is useful for server-to-server authentication where a user is not directly involved. Requires 'client_id' and 'client_secret'.

```http
POST /auth/realms/test-realm/protocol/openid-connect/token  
Host: app.phasetwo.io  
Accept: application/json  
Content-type: application/x-www-form-urlencoded  
  
grant_type=client_credentials&client_id=admin-cli&client_secret=fd649804-3a74-4d69-acaa-8f065c6b7da1  

```
Tokens:
Raw