User - RADIUS

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

Admin endpoints for RADIUS session management and monitoring. All endpoints require admin/staff authentication.

Online Sessions

Retrieve all currently active RADIUS sessions.

Property	Value
Endpoint	Online Sessions
Method	`GET`
URL	`/api/v1/radius/online-sessions`
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": [
        {
            "username": "subscriber001",
            "nas_ip": "192.168.1.1",
            "framed_ip": "10.0.0.5",
            "session_time": 3600,
            "input_octets": 1048576,
            "output_octets": 5242880,
            "start_time": "2024-01-15 09:30:00"
        }
    ],
    "total": 250
}

Code Examples:

bash

curl -X GET "https://your-domain.com/api/v1/radius/online-sessions" \
  -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/radius/online-sessions', [
    '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/radius/online-sessions`, {
  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/radius/online-sessions",
    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/radius/online-sessions"

	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/radius/online-sessions"))
        .header("Accept", "application/json")
        .bearer_auth(TOKEN)
        .send()
        .await?;

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

Session History

Retrieve session history for a specific subscriber.

Property	Value
Endpoint	Session History
Method	`GET`
URL	`/api/v1/radius/session-history`
Authentication	Bearer Token

Query Parameters:

Parameter	Type	Required	Description
`username`	string	Yes	Subscriber username
`from_date`	date	No	Start date filter
`to_date`	date	No	End date filter

Success Response (200 OK):

json

{
    "success": true,
    "data": [
        {
            "session_id": "abc123",
            "start_time": "2024-01-15 09:30:00",
            "stop_time": "2024-01-15 10:30:00",
            "session_time": 3600,
            "input_octets": 1048576,
            "output_octets": 5242880,
            "terminate_cause": "User-Request"
        }
    ]
}

Code Examples:

bash

curl -X GET "https://your-domain.com/api/v1/radius/session-history?username=subscriber001" \
  -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/radius/session-history', [
    'headers' => [
        'Accept'        => 'application/json',
        'Authorization' => 'Bearer your-auth-token',
    ],
    'query' => [
        'username' => 'subscriber001',
    ],
]);

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

javascript

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

const params = new URLSearchParams({
  username: 'subscriber001',
});

const response = await fetch(`${BASE_URL}/api/v1/radius/session-history?${params}`, {
  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/radius/session-history",
    headers={
        "Accept": "application/json",
        "Authorization": f"Bearer {TOKEN}",
    },
    params={
        "username": "subscriber001",
    },
)

data = response.json()
print(data)

package main

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

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

func main() {
	endpoint := baseURL + "/api/v1/radius/session-history"

	q := url.Values{}
	q.Set("username", "subscriber001")
	endpoint += "?" + q.Encode()

	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/radius/session-history"))
        .header("Accept", "application/json")
        .bearer_auth(TOKEN)
        .query(&[
            ("username", "subscriber001"),
        ])
        .send()
        .await?;

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

Get Subscriber Radcheck

Retrieve radcheck attributes for a subscriber.

Property	Value
Endpoint	Get Radcheck
Method	`GET`
URL	`/api/v1/radius/radcheck/{username}`
Authentication	Bearer Token

Success Response (200 OK):

json

{
    "success": true,
    "data": [
        {
            "id": 1,
            "attribute": "Cleartext-Password",
            "op": ":=",
            "value": "***hidden***"
        }
    ]
}

Code Examples:

bash

curl -X GET "https://your-domain.com/api/v1/radius/radcheck/subscriber001" \
  -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']);

$username = 'subscriber001';

$response = $client->request('GET', "/api/v1/radius/radcheck/{$username}", [
    '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 username = "subscriber001";

const response = await fetch(`${BASE_URL}/api/v1/radius/radcheck/${username}`, {
  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"

username = "subscriber001"

response = requests.get(
    f"{BASE_URL}/api/v1/radius/radcheck/{username}",
    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() {
	username := "subscriber001"
	endpoint := baseURL + "/api/v1/radius/radcheck/" + username

	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 username = "subscriber001";

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

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

Get Subscriber Radreply

Retrieve radreply attributes for a subscriber.

Property	Value
Endpoint	Get Radreply
Method	`GET`
URL	`/api/v1/radius/radreply/{username}`
Authentication	Bearer Token

Success Response (200 OK):

json

{
    "success": true,
    "data": [
        {
            "id": 1,
            "attribute": "Framed-IP-Address",
            "op": ":=",
            "value": "10.0.0.5"
        }
    ]
}

Code Examples:

bash

curl -X GET "https://your-domain.com/api/v1/radius/radreply/subscriber001" \
  -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']);

$username = 'subscriber001';

$response = $client->request('GET', "/api/v1/radius/radreply/{$username}", [
    '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 username = "subscriber001";

const response = await fetch(`${BASE_URL}/api/v1/radius/radreply/${username}`, {
  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"

username = "subscriber001"

response = requests.get(
    f"{BASE_URL}/api/v1/radius/radreply/{username}",
    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() {
	username := "subscriber001"
	endpoint := baseURL + "/api/v1/radius/radreply/" + username

	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 username = "subscriber001";

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

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

Get Subscriber Radusergroup

Retrieve group membership for a subscriber.

Property	Value
Endpoint	Get Radusergroup
Method	`GET`
URL	`/api/v1/radius/radusergroup/{username}`
Authentication	Bearer Token

Success Response (200 OK):

json

{
    "success": true,
    "data": [
        {
            "groupname": "10MB-Package",
            "priority": 1
        }
    ]
}

Code Examples:

bash

curl -X GET "https://your-domain.com/api/v1/radius/radusergroup/subscriber001" \
  -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']);

$username = 'subscriber001';

$response = $client->request('GET', "/api/v1/radius/radusergroup/{$username}", [
    '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 username = "subscriber001";

const response = await fetch(`${BASE_URL}/api/v1/radius/radusergroup/${username}`, {
  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"

username = "subscriber001"

response = requests.get(
    f"{BASE_URL}/api/v1/radius/radusergroup/{username}",
    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() {
	username := "subscriber001"
	endpoint := baseURL + "/api/v1/radius/radusergroup/" + username

	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 username = "subscriber001";

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

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

Get Usage Stats

Retrieve bandwidth usage statistics for a subscriber.

Property	Value
Endpoint	Get Usage Stats
Method	`GET`
URL	`/api/v1/radius/usage-stats/{username}`
Authentication	Bearer Token

Success Response (200 OK):

json

{
    "success": true,
    "data": {
        "total_download": "15.5 GB",
        "total_upload": "2.3 GB",
        "total_sessions": 45,
        "total_session_time": "120 hours",
        "current_month_download": "5.2 GB",
        "current_month_upload": "800 MB"
    }
}

Code Examples:

bash

curl -X GET "https://your-domain.com/api/v1/radius/usage-stats/subscriber001" \
  -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']);

$username = 'subscriber001';

$response = $client->request('GET', "/api/v1/radius/usage-stats/{$username}", [
    '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 username = "subscriber001";

const response = await fetch(`${BASE_URL}/api/v1/radius/usage-stats/${username}`, {
  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"

username = "subscriber001"

response = requests.get(
    f"{BASE_URL}/api/v1/radius/usage-stats/{username}",
    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() {
	username := "subscriber001"
	endpoint := baseURL + "/api/v1/radius/usage-stats/" + username

	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 username = "subscriber001";

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

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

Disconnect Session

Force disconnect a subscriber's live PPPoE / Hotspot session. Issues a real RADIUS Packet-of-Disconnect (CoA) to the NAS — not just a DB-level mark.

Updated in v2.22.26

The endpoint now sends a real CoA via RadiusServices so the subscriber is actually dropped on the NAS, not only flagged in radacct. The input contract is also updated: pass subscriber_id (preferred) or session_id.

Property	Value
Endpoint	Disconnect Session
Method	`POST`
URL	`/api/v1/radius/disconnect`
Authentication	Bearer Token

Request Headers:

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

Request Body:

json

{
    "isp_id": 1,
    "branch_id": 1,
    "user_id": 5,
    "subscriber_id": 42
}

Parameter	Type	Required	Description
`isp_id`	integer	Yes	ISP ID
`branch_id`	integer	Yes	Branch ID
`user_id`	integer	Yes	Action-by user ID (admin/staff)
`subscriber_id`	integer	Conditional	Required if `session_id` is not provided
`session_id`	string	Conditional	RADIUS `acctsessionid`. Required if `subscriber_id` is not provided

Success Response (200 OK):

json

{
    "status": "success",
    "message": "Disconnect request sent successfully.",
    "data": {
        "subscriber_id": 42,
        "username": "subscriber001"
    }
}

Error Responses:

json

// 404 Not Found — subscriber or active session not found
{
    "status": "error",
    "message": "Subscriber not found."
}

json

// 409 Conflict — subscriber is not currently online
{
    "status": "error",
    "message": "Subscriber Not Online!"
}

json

// 422 Validation Error — neither subscriber_id nor session_id supplied
{
    "status": "error",
    "message": ["The subscriber id field is required when session id is not present."]
}

Code Examples:

bash

curl -X POST "https://your-domain.com/api/v1/radius/disconnect" \
  -H "Accept: application/json" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer your-auth-token" \
  -d '{
    "isp_id": 1,
    "branch_id": 1,
    "user_id": 5,
    "subscriber_id": 42
  }'

php

<?php

require 'vendor/autoload.php';

use GuzzleHttp\Client;

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

$response = $client->request('POST', '/api/v1/radius/disconnect', [
    'headers' => [
        'Accept'        => 'application/json',
        'Authorization' => 'Bearer your-auth-token',
    ],
    'json' => [
        'isp_id'        => 1,
        'branch_id'     => 1,
        'user_id'       => 5,
        'subscriber_id' => 42,
    ],
]);

$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/radius/disconnect`, {
  method: 'POST',
  headers: {
    Accept: 'application/json',
    'Content-Type': 'application/json',
    Authorization: `Bearer ${TOKEN}`,
  },
  body: JSON.stringify({
    isp_id: 1,
    branch_id: 1,
    user_id: 5,
    subscriber_id: 42,
  }),
});

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/radius/disconnect",
    headers={
        "Accept": "application/json",
        "Authorization": f"Bearer {TOKEN}",
    },
    json={
        "isp_id": 1,
        "branch_id": 1,
        "user_id": 5,
        "subscriber_id": 42,
    },
)

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/radius/disconnect"

	payload, _ := json.Marshal(map[string]any{
		"isp_id":        1,
		"branch_id":     1,
		"user_id":       5,
		"subscriber_id": 42,
	})
	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/radius/disconnect"))
        .header("Accept", "application/json")
        .bearer_auth(TOKEN)
        .json(&json!({
            "isp_id": 1,
            "branch_id": 1,
            "user_id": 5,
            "subscriber_id": 42
        }))
        .send()
        .await?;

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

User - RADIUS ​

Online Sessions ​

Session History ​

Get Subscriber Radcheck ​

Get Subscriber Radreply ​

Get Subscriber Radusergroup ​

Get Usage Stats ​

Disconnect Session ​

User - RADIUS

Online Sessions

Session History

Get Subscriber Radcheck

Get Subscriber Radreply

Get Subscriber Radusergroup

Get Usage Stats

Disconnect Session