User - Activity Logs

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

Admin endpoints for viewing system activity logs. All endpoints require admin authentication.

Fetch All Activity Logs

Retrieve all activity logs with pagination.

Property	Value
Endpoint	Fetch All Activity Logs
Method	`GET`
URL	`/api/v1/activity-logs`
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,
            "user_id": 1,
            "user_name": "Admin",
            "action": "created",
            "subject_type": "Subscriber",
            "subject_id": 5,
            "description": "Created subscriber John Doe",
            "created_at": "2024-01-15 10:30:00"
        }
    ]
}

Code Examples:

bash

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

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

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

Fetch Activity Log

Retrieve details of a specific activity log entry.

Property	Value
Endpoint	Fetch Activity Log
Method	`GET`
URL	`/api/v1/activity-logs/{id}`
Authentication	Bearer Token

Success Response (200 OK):

json

{
    "success": true,
    "data": {
        "id": 1,
        "user_id": 1,
        "user_name": "Admin",
        "action": "created",
        "subject_type": "Subscriber",
        "subject_id": 5,
        "description": "Created subscriber John Doe",
        "properties": {"old": {}, "new": {"name": "John Doe"}},
        "ip_address": "192.168.1.100",
        "created_at": "2024-01-15 10:30:00"
    }
}

Code Examples:

bash

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

$activityLogId = 1;

$response = $client->request('GET', "/api/v1/activity-logs/{$activityLogId}", [
    '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 activityLogId = 1;

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

activity_log_id = 1

response = requests.get(
    f"{BASE_URL}/api/v1/activity-logs/{activity_log_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() {
	activityLogId := 1
	endpoint := baseURL + "/api/v1/activity-logs/" + strconv.Itoa(activityLogId)

	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 activity_log_id = 1;

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

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

Fetch Logs By Subject

Get activity logs for a specific subject (entity).

Property	Value
Endpoint	Fetch Logs By Subject
Method	`GET`
URL	`/api/v1/activity-logs/by-subject`
Authentication	Bearer Token

Query Parameters:

Parameter	Type	Required	Description
`subject_type`	string	Yes	Entity type (Subscriber, Package, etc.)
`subject_id`	integer	Yes	Entity ID

Success Response (200 OK):

json

{
    "success": true,
    "data": [
        {
            "id": 1,
            "action": "updated",
            "user_name": "Admin",
            "description": "Updated subscriber package",
            "created_at": "2024-01-15 10:30:00"
        }
    ]
}

Code Examples:

bash

curl -X GET "https://your-domain.com/api/v1/activity-logs/by-subject?subject_type=example&subject_id=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']);

$response = $client->request('GET', '/api/v1/activity-logs/by-subject', [
    'headers' => [
        'Accept'        => 'application/json',
        'Authorization' => 'Bearer your-auth-token',
    ],
    'query' => [
        'subject_type' => 'example',
        'subject_id'   => 1,
    ],
]);

$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({
  subject_type: 'example',
  subject_id: 1,
});

const response = await fetch(`${BASE_URL}/api/v1/activity-logs/by-subject?${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/activity-logs/by-subject",
    headers={
        "Accept": "application/json",
        "Authorization": f"Bearer {TOKEN}",
    },
    params={
        "subject_type": "example",
        "subject_id": 1,
    },
)

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/activity-logs/by-subject"

	q := url.Values{}
	q.Set("subject_type", "example")
	q.Set("subject_id", "1")
	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/activity-logs/by-subject"))
        .header("Accept", "application/json")
        .bearer_auth(TOKEN)
        .query(&[
            ("subject_type", "example"),
            ("subject_id", "1"),
        ])
        .send()
        .await?;

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

Fetch Logs By User

Get activity logs for a specific user.

Property	Value
Endpoint	Fetch Logs By User
Method	`GET`
URL	`/api/v1/activity-logs/by-user/{user_id}`
Authentication	Bearer Token

Success Response (200 OK):

json

{
    "success": true,
    "data": [
        {
            "id": 1,
            "action": "created",
            "subject_type": "Subscriber",
            "description": "Created subscriber John Doe",
            "created_at": "2024-01-15 10:30:00"
        }
    ]
}

Code Examples:

bash

curl -X GET "https://your-domain.com/api/v1/activity-logs/by-user/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']);

$userId = 1;

$response = $client->request('GET', "/api/v1/activity-logs/by-user/{$userId}", [
    '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 userId = 1;

const response = await fetch(`${BASE_URL}/api/v1/activity-logs/by-user/${userId}`, {
  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"

user_id = 1

response = requests.get(
    f"{BASE_URL}/api/v1/activity-logs/by-user/{user_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() {
	userId := 1
	endpoint := baseURL + "/api/v1/activity-logs/by-user/" + strconv.Itoa(userId)

	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 user_id = 1;

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

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

User - Activity Logs ​

Fetch All Activity Logs ​

Fetch Activity Log ​

Fetch Logs By Subject ​

Fetch Logs By User ​

User - Activity Logs

Fetch All Activity Logs

Fetch Activity Log

Fetch Logs By Subject

Fetch Logs By User