User - Policies

Base URL: https://your-domain.com

Admin endpoints for managing RADIUS policies and attributes. All endpoints require admin/staff authentication.

Fetch All Policies

Retrieve all RADIUS policies configured in the system.

Property	Value
Endpoint	Fetch All Policies
Method	`GET`
URL	`/api/v1/policies`
Authentication	Bearer Token

Request Headers:

Header	Value	Required
`Accept`	`application/json`	Yes
`Authorization`	`Bearer your-auth-token`	Yes

Success Response (200 OK):

json

{
    "success": true,
    "data": [
        {
            "id": 1,
            "name": "Default Policy",
            "attribute_count": 5,
            "package_count": 3
        }
    ]
}

Code Examples:

bash

curl -X GET "https://your-domain.com/api/v1/policies" \
  -H "Accept: application/json" \
  -H "Authorization: Bearer your-auth-token"

php

<?php

require 'vendor/autoload.php';

use GuzzleHttp\Client;

$client = new Client(['base_uri' => 'https://your-domain.com']);

$response = $client->request('GET', '/api/v1/policies', [
    'headers' => [
        'Accept'        => 'application/json',
        'Authorization' => 'Bearer your-auth-token',
    ],
]);

$data = json_decode($response->getBody(), true);
print_r($data);

javascript

const BASE_URL = 'https://your-domain.com';
const TOKEN = 'your-auth-token';

const response = await fetch(`${BASE_URL}/api/v1/policies`, {
  method: 'GET',
  headers: {
    Accept: 'application/json',
    Authorization: `Bearer ${TOKEN}`,
  },
});

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

python

import requests

BASE_URL = "https://your-domain.com"
TOKEN = "your-auth-token"

response = requests.get(
    f"{BASE_URL}/api/v1/policies",
    headers={
        "Accept": "application/json",
        "Authorization": f"Bearer {TOKEN}",
    },
)

data = response.json()
print(data)

package main

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

const baseURL = "https://your-domain.com"
const token = "your-auth-token"

func main() {
	endpoint := baseURL + "/api/v1/policies"

	req, _ := http.NewRequest("GET", endpoint, nil)
	req.Header.Set("Accept", "application/json")
	req.Header.Set("Authorization", "Bearer "+token)

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	body, _ := io.ReadAll(resp.Body)
	fmt.Println(resp.StatusCode, string(body))
}

rust

use reqwest::Client;

const BASE_URL: &str = "https://your-domain.com";
const TOKEN: &str = "your-auth-token";

#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
    let client = Client::new();

    let response = client
        .get(format!("{BASE_URL}/api/v1/policies"))
        .header("Accept", "application/json")
        .bearer_auth(TOKEN)
        .send()
        .await?;

    let data: serde_json::Value = response.json().await?;
    println!("{data:#}");
    Ok(())
}

Fetch Policy

Retrieve details of a specific policy including its attributes.

Property	Value
Endpoint	Fetch Policy
Method	`GET`
URL	`/api/v1/policies/{id}`
Authentication	Bearer Token

Success Response (200 OK):

json

{
    "success": true,
    "data": {
        "id": 1,
        "name": "Default Policy",
        "attributes": [
            {
                "id": 1,
                "attribute": "Framed-Protocol",
                "op": ":=",
                "value": "PPP"
            }
        ]
    }
}

Code Examples:

bash

curl -X GET "https://your-domain.com/api/v1/policies/1" \
  -H "Accept: application/json" \
  -H "Authorization: Bearer your-auth-token"

php

<?php

require 'vendor/autoload.php';

use GuzzleHttp\Client;

$client = new Client(['base_uri' => 'https://your-domain.com']);

$policyId = 1;

$response = $client->request('GET', "/api/v1/policies/{$policyId}", [
    'headers' => [
        'Accept'        => 'application/json',
        'Authorization' => 'Bearer your-auth-token',
    ],
]);

$data = json_decode($response->getBody(), true);
print_r($data);

javascript

const BASE_URL = 'https://your-domain.com';
const TOKEN = 'your-auth-token';

const policyId = 1;

const response = await fetch(`${BASE_URL}/api/v1/policies/${policyId}`, {
  method: 'GET',
  headers: {
    Accept: 'application/json',
    Authorization: `Bearer ${TOKEN}`,
  },
});

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

python

import requests

BASE_URL = "https://your-domain.com"
TOKEN = "your-auth-token"

policy_id = 1

response = requests.get(
    f"{BASE_URL}/api/v1/policies/{policy_id}",
    headers={
        "Accept": "application/json",
        "Authorization": f"Bearer {TOKEN}",
    },
)

data = response.json()
print(data)

package main

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

const baseURL = "https://your-domain.com"
const token = "your-auth-token"

func main() {
	policyId := 1
	endpoint := baseURL + "/api/v1/policies/" + strconv.Itoa(policyId)

	req, _ := http.NewRequest("GET", endpoint, nil)
	req.Header.Set("Accept", "application/json")
	req.Header.Set("Authorization", "Bearer "+token)

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	body, _ := io.ReadAll(resp.Body)
	fmt.Println(resp.StatusCode, string(body))
}

rust

use reqwest::Client;

const BASE_URL: &str = "https://your-domain.com";
const TOKEN: &str = "your-auth-token";

#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
    let client = Client::new();
    let policy_id = 1;

    let response = client
        .get(format!("{BASE_URL}/api/v1/policies/{policy_id}"))
        .header("Accept", "application/json")
        .bearer_auth(TOKEN)
        .send()
        .await?;

    let data: serde_json::Value = response.json().await?;
    println!("{data:#}");
    Ok(())
}

Create Policy

Create a new RADIUS policy.

Property	Value
Endpoint	Create Policy
Method	`POST`
URL	`/api/v1/policies`
Authentication	Bearer Token

Request Body:

json

{
    "isp_id": 1,
    "branch_id": 1,
    "user_id": 1,
    "name": "Default Policy"
}

Success Response (201 Created):

json

{
    "success": true,
    "message": "Policy created successfully",
    "data": {
        "id": 1
    }
}

Code Examples:

bash

curl -X POST "https://your-domain.com/api/v1/policies" \
  -H "Accept: application/json" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer your-auth-token" \
  -d '{
    "isp_id": 1,
    "branch_id": 1,
    "user_id": 1,
    "name": "Default Policy"
  }'

php

<?php

require 'vendor/autoload.php';

use GuzzleHttp\Client;

$client = new Client(['base_uri' => 'https://your-domain.com']);

$response = $client->request('POST', '/api/v1/policies', [
    'headers' => [
        'Accept'        => 'application/json',
        'Authorization' => 'Bearer your-auth-token',
    ],
    'json' => [
        'isp_id'    => 1,
        'branch_id' => 1,
        'user_id'   => 1,
        'name'      => 'Default Policy',
    ],
]);

$data = json_decode($response->getBody(), true);
print_r($data);

javascript

const BASE_URL = 'https://your-domain.com';
const TOKEN = 'your-auth-token';

const response = await fetch(`${BASE_URL}/api/v1/policies`, {
  method: 'POST',
  headers: {
    Accept: 'application/json',
    'Content-Type': 'application/json',
    Authorization: `Bearer ${TOKEN}`,
  },
  body: JSON.stringify({
    isp_id: 1,
    branch_id: 1,
    user_id: 1,
    name: 'Default Policy',
  }),
});

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

python

import requests

BASE_URL = "https://your-domain.com"
TOKEN = "your-auth-token"

response = requests.post(
    f"{BASE_URL}/api/v1/policies",
    headers={
        "Accept": "application/json",
        "Authorization": f"Bearer {TOKEN}",
    },
    json={
        "isp_id": 1,
        "branch_id": 1,
        "user_id": 1,
        "name": "Default Policy",
    },
)

data = response.json()
print(data)

package main

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

const baseURL = "https://your-domain.com"
const token = "your-auth-token"

func main() {
	endpoint := baseURL + "/api/v1/policies"

	payload, _ := json.Marshal(map[string]any{
		"isp_id":    1,
		"branch_id": 1,
		"user_id":   1,
		"name":      "Default Policy",
	})
	req, _ := http.NewRequest("POST", endpoint, bytes.NewBuffer(payload))
	req.Header.Set("Accept", "application/json")
	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("Authorization", "Bearer "+token)

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	body, _ := io.ReadAll(resp.Body)
	fmt.Println(resp.StatusCode, string(body))
}

rust

use reqwest::Client;
use serde_json::json;

const BASE_URL: &str = "https://your-domain.com";
const TOKEN: &str = "your-auth-token";

#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
    let client = Client::new();

    let response = client
        .post(format!("{BASE_URL}/api/v1/policies"))
        .header("Accept", "application/json")
        .bearer_auth(TOKEN)
        .json(&json!({
            "isp_id": 1,
            "branch_id": 1,
            "user_id": 1,
            "name": "Default Policy"
        }))
        .send()
        .await?;

    let data: serde_json::Value = response.json().await?;
    println!("{data:#}");
    Ok(())
}

Update Policy

Update an existing policy.

Property	Value
Endpoint	Update Policy
Method	`PUT`
URL	`/api/v1/policies/{id}`
Authentication	Bearer Token

Request Body:

json

{
    "name": "Updated Policy"
}

Success Response (200 OK):

json

{
    "success": true,
    "message": "Policy updated successfully"
}

Code Examples:

bash

curl -X PUT "https://your-domain.com/api/v1/policies/1" \
  -H "Accept: application/json" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer your-auth-token" \
  -d '{
    "name": "Updated Policy"
  }'

php

<?php

require 'vendor/autoload.php';

use GuzzleHttp\Client;

$client = new Client(['base_uri' => 'https://your-domain.com']);

$policyId = 1;

$response = $client->request('PUT', "/api/v1/policies/{$policyId}", [
    'headers' => [
        'Accept'        => 'application/json',
        'Authorization' => 'Bearer your-auth-token',
    ],
    'json' => [
        'name' => 'Updated Policy',
    ],
]);

$data = json_decode($response->getBody(), true);
print_r($data);

javascript

const BASE_URL = 'https://your-domain.com';
const TOKEN = 'your-auth-token';

const policyId = 1;

const response = await fetch(`${BASE_URL}/api/v1/policies/${policyId}`, {
  method: 'PUT',
  headers: {
    Accept: 'application/json',
    'Content-Type': 'application/json',
    Authorization: `Bearer ${TOKEN}`,
  },
  body: JSON.stringify({
    name: 'Updated Policy',
  }),
});

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

python

import requests

BASE_URL = "https://your-domain.com"
TOKEN = "your-auth-token"

policy_id = 1

response = requests.put(
    f"{BASE_URL}/api/v1/policies/{policy_id}",
    headers={
        "Accept": "application/json",
        "Authorization": f"Bearer {TOKEN}",
    },
    json={
        "name": "Updated Policy",
    },
)

data = response.json()
print(data)

package main

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

const baseURL = "https://your-domain.com"
const token = "your-auth-token"

func main() {
	policyId := 1
	endpoint := baseURL + "/api/v1/policies/" + strconv.Itoa(policyId)

	payload, _ := json.Marshal(map[string]any{
		"name": "Updated Policy",
	})
	req, _ := http.NewRequest("PUT", endpoint, bytes.NewBuffer(payload))
	req.Header.Set("Accept", "application/json")
	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("Authorization", "Bearer "+token)

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	body, _ := io.ReadAll(resp.Body)
	fmt.Println(resp.StatusCode, string(body))
}

rust

use reqwest::Client;
use serde_json::json;

const BASE_URL: &str = "https://your-domain.com";
const TOKEN: &str = "your-auth-token";

#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
    let client = Client::new();
    let policy_id = 1;

    let response = client
        .put(format!("{BASE_URL}/api/v1/policies/{policy_id}"))
        .header("Accept", "application/json")
        .bearer_auth(TOKEN)
        .json(&json!({
            "name": "Updated Policy"
        }))
        .send()
        .await?;

    let data: serde_json::Value = response.json().await?;
    println!("{data:#}");
    Ok(())
}

Delete Policy

Delete a policy from the system.

Property	Value
Endpoint	Delete Policy
Method	`DELETE`
URL	`/api/v1/policies/{id}`
Authentication	Bearer Token

Success Response (200 OK):

json

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

Policy Attributes

Manage RADIUS attributes within a policy.

Code Examples:

bash

curl -X DELETE "https://your-domain.com/api/v1/policies/1" \
  -H "Accept: application/json" \
  -H "Authorization: Bearer your-auth-token"

php

<?php

require 'vendor/autoload.php';

use GuzzleHttp\Client;

$client = new Client(['base_uri' => 'https://your-domain.com']);

$policyId = 1;

$response = $client->request('DELETE', "/api/v1/policies/{$policyId}", [
    'headers' => [
        'Accept'        => 'application/json',
        'Authorization' => 'Bearer your-auth-token',
    ],
]);

$data = json_decode($response->getBody(), true);
print_r($data);

javascript

const BASE_URL = 'https://your-domain.com';
const TOKEN = 'your-auth-token';

const policyId = 1;

const response = await fetch(`${BASE_URL}/api/v1/policies/${policyId}`, {
  method: 'DELETE',
  headers: {
    Accept: 'application/json',
    Authorization: `Bearer ${TOKEN}`,
  },
});

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

python

import requests

BASE_URL = "https://your-domain.com"
TOKEN = "your-auth-token"

policy_id = 1

response = requests.delete(
    f"{BASE_URL}/api/v1/policies/{policy_id}",
    headers={
        "Accept": "application/json",
        "Authorization": f"Bearer {TOKEN}",
    },
)

data = response.json()
print(data)

package main

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

const baseURL = "https://your-domain.com"
const token = "your-auth-token"

func main() {
	policyId := 1
	endpoint := baseURL + "/api/v1/policies/" + strconv.Itoa(policyId)

	req, _ := http.NewRequest("DELETE", endpoint, nil)
	req.Header.Set("Accept", "application/json")
	req.Header.Set("Authorization", "Bearer "+token)

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	body, _ := io.ReadAll(resp.Body)
	fmt.Println(resp.StatusCode, string(body))
}

rust

use reqwest::Client;

const BASE_URL: &str = "https://your-domain.com";
const TOKEN: &str = "your-auth-token";

#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
    let client = Client::new();
    let policy_id = 1;

    let response = client
        .delete(format!("{BASE_URL}/api/v1/policies/{policy_id}"))
        .header("Accept", "application/json")
        .bearer_auth(TOKEN)
        .send()
        .await?;

    let data: serde_json::Value = response.json().await?;
    println!("{data:#}");
    Ok(())
}

Fetch Policy Attributes

Retrieve all attributes for a specific policy.

Property	Value
Endpoint	Fetch Policy Attributes
Method	`GET`
URL	`/api/v1/policies/{id}/attributes`
Authentication	Bearer Token

Success Response (200 OK):

json

{
    "success": true,
    "data": [
        {
            "id": 1,
            "attribute": "Framed-Protocol",
            "op": ":=",
            "value": "PPP"
        }
    ]
}

Code Examples:

bash

curl -X GET "https://your-domain.com/api/v1/policies/1/attributes" \
  -H "Accept: application/json" \
  -H "Authorization: Bearer your-auth-token"

php

<?php

require 'vendor/autoload.php';

use GuzzleHttp\Client;

$client = new Client(['base_uri' => 'https://your-domain.com']);

$policyId = 1;

$response = $client->request('GET', "/api/v1/policies/{$policyId}/attributes", [
    'headers' => [
        'Accept'        => 'application/json',
        'Authorization' => 'Bearer your-auth-token',
    ],
]);

$data = json_decode($response->getBody(), true);
print_r($data);

javascript

const BASE_URL = 'https://your-domain.com';
const TOKEN = 'your-auth-token';

const policyId = 1;

const response = await fetch(`${BASE_URL}/api/v1/policies/${policyId}/attributes`, {
  method: 'GET',
  headers: {
    Accept: 'application/json',
    Authorization: `Bearer ${TOKEN}`,
  },
});

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

python

import requests

BASE_URL = "https://your-domain.com"
TOKEN = "your-auth-token"

policy_id = 1

response = requests.get(
    f"{BASE_URL}/api/v1/policies/{policy_id}/attributes",
    headers={
        "Accept": "application/json",
        "Authorization": f"Bearer {TOKEN}",
    },
)

data = response.json()
print(data)

package main

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

const baseURL = "https://your-domain.com"
const token = "your-auth-token"

func main() {
	policyId := 1
	endpoint := baseURL + "/api/v1/policies/" + strconv.Itoa(policyId) + "/attributes"

	req, _ := http.NewRequest("GET", endpoint, nil)
	req.Header.Set("Accept", "application/json")
	req.Header.Set("Authorization", "Bearer "+token)

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	body, _ := io.ReadAll(resp.Body)
	fmt.Println(resp.StatusCode, string(body))
}

rust

use reqwest::Client;

const BASE_URL: &str = "https://your-domain.com";
const TOKEN: &str = "your-auth-token";

#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
    let client = Client::new();
    let policy_id = 1;

    let response = client
        .get(format!("{BASE_URL}/api/v1/policies/{policy_id}/attributes"))
        .header("Accept", "application/json")
        .bearer_auth(TOKEN)
        .send()
        .await?;

    let data: serde_json::Value = response.json().await?;
    println!("{data:#}");
    Ok(())
}

Create Policy Attribute

Add a new attribute to a policy.

Property	Value
Endpoint	Create Policy Attribute
Method	`POST`
URL	`/api/v1/policies/{id}/attributes`
Authentication	Bearer Token

Request Body:

json

{
    "isp_id": 1,
    "branch_id": 1,
    "user_id": 1,
    "attribute": "Framed-Protocol",
    "op": ":=",
    "value": "PPP"
}

Parameter	Type	Required	Description
`attribute`	string	Yes	RADIUS attribute name
`op`	string	Yes	Operator (:=, ==, !=, etc.)
`value`	string	Yes	Attribute value

Success Response (201 Created):

json

{
    "success": true,
    "message": "Attribute added successfully"
}

Code Examples:

bash

curl -X POST "https://your-domain.com/api/v1/policies/1/attributes" \
  -H "Accept: application/json" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer your-auth-token" \
  -d '{
    "isp_id": 1,
    "branch_id": 1,
    "user_id": 1,
    "attribute": "Framed-Protocol",
    "op": ":=",
    "value": "PPP"
  }'

php

<?php

require 'vendor/autoload.php';

use GuzzleHttp\Client;

$client = new Client(['base_uri' => 'https://your-domain.com']);

$policyId = 1;

$response = $client->request('POST', "/api/v1/policies/{$policyId}/attributes", [
    'headers' => [
        'Accept'        => 'application/json',
        'Authorization' => 'Bearer your-auth-token',
    ],
    'json' => [
        'isp_id'    => 1,
        'branch_id' => 1,
        'user_id'   => 1,
        'attribute' => 'Framed-Protocol',
        'op'        => ':=',
        'value'     => 'PPP',
    ],
]);

$data = json_decode($response->getBody(), true);
print_r($data);

javascript

const BASE_URL = 'https://your-domain.com';
const TOKEN = 'your-auth-token';

const policyId = 1;

const response = await fetch(`${BASE_URL}/api/v1/policies/${policyId}/attributes`, {
  method: 'POST',
  headers: {
    Accept: 'application/json',
    'Content-Type': 'application/json',
    Authorization: `Bearer ${TOKEN}`,
  },
  body: JSON.stringify({
    isp_id: 1,
    branch_id: 1,
    user_id: 1,
    attribute: 'Framed-Protocol',
    op: ':=',
    value: 'PPP',
  }),
});

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

python

import requests

BASE_URL = "https://your-domain.com"
TOKEN = "your-auth-token"

policy_id = 1

response = requests.post(
    f"{BASE_URL}/api/v1/policies/{policy_id}/attributes",
    headers={
        "Accept": "application/json",
        "Authorization": f"Bearer {TOKEN}",
    },
    json={
        "isp_id": 1,
        "branch_id": 1,
        "user_id": 1,
        "attribute": "Framed-Protocol",
        "op": ":=",
        "value": "PPP",
    },
)

data = response.json()
print(data)

package main

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

const baseURL = "https://your-domain.com"
const token = "your-auth-token"

func main() {
	policyId := 1
	endpoint := baseURL + "/api/v1/policies/" + strconv.Itoa(policyId) + "/attributes"

	payload, _ := json.Marshal(map[string]any{
		"isp_id":    1,
		"branch_id": 1,
		"user_id":   1,
		"attribute": "Framed-Protocol",
		"op":        ":=",
		"value":     "PPP",
	})
	req, _ := http.NewRequest("POST", endpoint, bytes.NewBuffer(payload))
	req.Header.Set("Accept", "application/json")
	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("Authorization", "Bearer "+token)

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	body, _ := io.ReadAll(resp.Body)
	fmt.Println(resp.StatusCode, string(body))
}

rust

use reqwest::Client;
use serde_json::json;

const BASE_URL: &str = "https://your-domain.com";
const TOKEN: &str = "your-auth-token";

#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
    let client = Client::new();
    let policy_id = 1;

    let response = client
        .post(format!("{BASE_URL}/api/v1/policies/{policy_id}/attributes"))
        .header("Accept", "application/json")
        .bearer_auth(TOKEN)
        .json(&json!({
            "isp_id": 1,
            "branch_id": 1,
            "user_id": 1,
            "attribute": "Framed-Protocol",
            "op": ":=",
            "value": "PPP"
        }))
        .send()
        .await?;

    let data: serde_json::Value = response.json().await?;
    println!("{data:#}");
    Ok(())
}

Update Policy Attribute

Update an existing policy attribute.

Property	Value
Endpoint	Update Policy Attribute
Method	`PUT`
URL	`/api/v1/policies/{id}/attributes/{attr_id}`
Authentication	Bearer Token

Success Response (200 OK):

json

{
    "success": true,
    "message": "Attribute updated successfully"
}

Code Examples:

bash

curl -X PUT "https://your-domain.com/api/v1/policies/1/attributes/1" \
  -H "Accept: application/json" \
  -H "Authorization: Bearer your-auth-token"

php

<?php

require 'vendor/autoload.php';

use GuzzleHttp\Client;

$client = new Client(['base_uri' => 'https://your-domain.com']);

$policyId = 1;
$attrId = 1;

$response = $client->request('PUT', "/api/v1/policies/{$policyId}/attributes/{$attrId}", [
    'headers' => [
        'Accept'        => 'application/json',
        'Authorization' => 'Bearer your-auth-token',
    ],
]);

$data = json_decode($response->getBody(), true);
print_r($data);

javascript

const BASE_URL = 'https://your-domain.com';
const TOKEN = 'your-auth-token';

const policyId = 1;
const attrId = 1;

const response = await fetch(`${BASE_URL}/api/v1/policies/${policyId}/attributes/${attrId}`, {
  method: 'PUT',
  headers: {
    Accept: 'application/json',
    Authorization: `Bearer ${TOKEN}`,
  },
});

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

python

import requests

BASE_URL = "https://your-domain.com"
TOKEN = "your-auth-token"

policy_id = 1
attr_id = 1

response = requests.put(
    f"{BASE_URL}/api/v1/policies/{policy_id}/attributes/{attr_id}",
    headers={
        "Accept": "application/json",
        "Authorization": f"Bearer {TOKEN}",
    },
)

data = response.json()
print(data)

package main

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

const baseURL = "https://your-domain.com"
const token = "your-auth-token"

func main() {
	policyId := 1
	attrId := 1
	endpoint := baseURL + "/api/v1/policies/" + strconv.Itoa(policyId) + "/attributes/" + strconv.Itoa(attrId)

	req, _ := http.NewRequest("PUT", endpoint, nil)
	req.Header.Set("Accept", "application/json")
	req.Header.Set("Authorization", "Bearer "+token)

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	body, _ := io.ReadAll(resp.Body)
	fmt.Println(resp.StatusCode, string(body))
}

rust

use reqwest::Client;

const BASE_URL: &str = "https://your-domain.com";
const TOKEN: &str = "your-auth-token";

#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
    let client = Client::new();
    let policy_id = 1;
    let attr_id = 1;

    let response = client
        .put(format!("{BASE_URL}/api/v1/policies/{policy_id}/attributes/{attr_id}"))
        .header("Accept", "application/json")
        .bearer_auth(TOKEN)
        .send()
        .await?;

    let data: serde_json::Value = response.json().await?;
    println!("{data:#}");
    Ok(())
}

Delete Policy Attribute

Remove an attribute from a policy.

Property	Value
Endpoint	Delete Policy Attribute
Method	`DELETE`
URL	`/api/v1/policies/{id}/attributes/{attr_id}`
Authentication	Bearer Token

Success Response (200 OK):

json

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

Code Examples:

bash

curl -X DELETE "https://your-domain.com/api/v1/policies/1/attributes/1" \
  -H "Accept: application/json" \
  -H "Authorization: Bearer your-auth-token"

php

<?php

require 'vendor/autoload.php';

use GuzzleHttp\Client;

$client = new Client(['base_uri' => 'https://your-domain.com']);

$policyId = 1;
$attrId = 1;

$response = $client->request('DELETE', "/api/v1/policies/{$policyId}/attributes/{$attrId}", [
    'headers' => [
        'Accept'        => 'application/json',
        'Authorization' => 'Bearer your-auth-token',
    ],
]);

$data = json_decode($response->getBody(), true);
print_r($data);

javascript

const BASE_URL = 'https://your-domain.com';
const TOKEN = 'your-auth-token';

const policyId = 1;
const attrId = 1;

const response = await fetch(`${BASE_URL}/api/v1/policies/${policyId}/attributes/${attrId}`, {
  method: 'DELETE',
  headers: {
    Accept: 'application/json',
    Authorization: `Bearer ${TOKEN}`,
  },
});

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

python

import requests

BASE_URL = "https://your-domain.com"
TOKEN = "your-auth-token"

policy_id = 1
attr_id = 1

response = requests.delete(
    f"{BASE_URL}/api/v1/policies/{policy_id}/attributes/{attr_id}",
    headers={
        "Accept": "application/json",
        "Authorization": f"Bearer {TOKEN}",
    },
)

data = response.json()
print(data)

package main

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

const baseURL = "https://your-domain.com"
const token = "your-auth-token"

func main() {
	policyId := 1
	attrId := 1
	endpoint := baseURL + "/api/v1/policies/" + strconv.Itoa(policyId) + "/attributes/" + strconv.Itoa(attrId)

	req, _ := http.NewRequest("DELETE", endpoint, nil)
	req.Header.Set("Accept", "application/json")
	req.Header.Set("Authorization", "Bearer "+token)

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	body, _ := io.ReadAll(resp.Body)
	fmt.Println(resp.StatusCode, string(body))
}

rust

use reqwest::Client;

const BASE_URL: &str = "https://your-domain.com";
const TOKEN: &str = "your-auth-token";

#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
    let client = Client::new();
    let policy_id = 1;
    let attr_id = 1;

    let response = client
        .delete(format!("{BASE_URL}/api/v1/policies/{policy_id}/attributes/{attr_id}"))
        .header("Accept", "application/json")
        .bearer_auth(TOKEN)
        .send()
        .await?;

    let data: serde_json::Value = response.json().await?;
    println!("{data:#}");
    Ok(())
}

User - Policies ​

Fetch All Policies ​

Fetch Policy ​

Create Policy ​

Update Policy ​

Delete Policy ​

Policy Attributes ​

Fetch Policy Attributes ​

Create Policy Attribute ​

Update Policy Attribute ​

Delete Policy Attribute ​

User - Policies

Fetch All Policies

Fetch Policy

Create Policy

Update Policy

Delete Policy

Policy Attributes

Fetch Policy Attributes

Create Policy Attribute

Update Policy Attribute

Delete Policy Attribute