MENU navbar-image

Introduction

API complète pour la gestion scolaire - Élèves, Notes, Emplois du temps, Paiements et plus.

Bienvenue dans la documentation de l'API AcademiaPro. Cette documentation vous fournit toutes les informations nécessaires pour intégrer et utiliser notre système de gestion scolaire.

<aside>En faisant défiler, vous verrez des exemples de code dans différents langages de programmation dans la zone sombre à droite (ou dans le contenu sur mobile).
Vous pouvez changer le langage utilisé avec les onglets en haut à droite (ou depuis le menu de navigation en haut à gauche sur mobile).</aside>

Authenticating requests

To authenticate requests, include an Authorization header with the value "Bearer {YOUR_AUTH_TOKEN}".

All authenticated endpoints are marked with a requires authentication badge in the documentation below.

Vous pouvez obtenir votre token en vous connectant via l'endpoint /api/v1.0.0/login. Le token doit être envoyé dans le header Authorization avec le préfixe Bearer.

Endpoints

GET api/user

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/user" \
    --header "Authorization: Bearer {YOUR_AUTH_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/user"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/user';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost/api/user'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_TOKEN}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
vary: Origin
 

{
    "message": "Unauthenticated."
}

Request      

GET api/user

Headers

Authorization        

Example: Bearer {YOUR_AUTH_TOKEN}

Content-Type        

Example: application/json

Accept        

Example: application/json

POST api/v1.0.0/login

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1.0.0/login" \
    --header "Authorization: Bearer {YOUR_AUTH_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"phone\": \"vmqeopfuudtdsufvyvddq\",
    \"password\": \"O[2UZ5ij-e\\/dl4m{o,\"
}"

const url = new URL(
    "http://localhost/api/v1.0.0/login"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "phone": "vmqeopfuudtdsufvyvddq",
    "password": "O[2UZ5ij-e\/dl4m{o,"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1.0.0/login';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'phone' => 'vmqeopfuudtdsufvyvddq',
            'password' => 'O[2UZ5ij-e/dl4m{o,',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost/api/v1.0.0/login'
payload = {
    "phone": "vmqeopfuudtdsufvyvddq",
    "password": "O[2UZ5ij-e\/dl4m{o,"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_TOKEN}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Request      

POST api/v1.0.0/login

Headers

Authorization        

Example: Bearer {YOUR_AUTH_TOKEN}

Content-Type        

Example: application/json

Accept        

Example: application/json

Body Parameters

phone   string     

Must not be greater than 30 characters. Example: vmqeopfuudtdsufvyvddq

password   string     

Example: O[2UZ5ij-e/dl4m{o,

POST api/v1.0.0/otp-code

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1.0.0/otp-code" \
    --header "Authorization: Bearer {YOUR_AUTH_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1.0.0/otp-code"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1.0.0/otp-code';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost/api/v1.0.0/otp-code'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_TOKEN}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers)
response.json()

Request      

POST api/v1.0.0/otp-code

Headers

Authorization        

Example: Bearer {YOUR_AUTH_TOKEN}

Content-Type        

Example: application/json

Accept        

Example: application/json

Génère un OTP pour le reset mot de passe et le renvoie pour EmailJS

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1.0.0/forgot-password" \
    --header "Authorization: Bearer {YOUR_AUTH_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"email\": \"qkunze@example.com\"
}"

const url = new URL(
    "http://localhost/api/v1.0.0/forgot-password"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "email": "qkunze@example.com"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1.0.0/forgot-password';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'email' => 'qkunze@example.com',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost/api/v1.0.0/forgot-password'
payload = {
    "email": "qkunze@example.com"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_TOKEN}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Request      

POST api/v1.0.0/forgot-password

Headers

Authorization        

Example: Bearer {YOUR_AUTH_TOKEN}

Content-Type        

Example: application/json

Accept        

Example: application/json

Body Parameters

email   string     

Must be a valid email address. Example: qkunze@example.com

Réinitialise le mot de passe avec le code OTP

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1.0.0/reset-password" \
    --header "Authorization: Bearer {YOUR_AUTH_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"email\": \"qkunze@example.com\",
    \"otp\": \"consequatur\",
    \"password\": \"[2UZ5ij-e\\/dl4\"
}"

const url = new URL(
    "http://localhost/api/v1.0.0/reset-password"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "email": "qkunze@example.com",
    "otp": "consequatur",
    "password": "[2UZ5ij-e\/dl4"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1.0.0/reset-password';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'email' => 'qkunze@example.com',
            'otp' => 'consequatur',
            'password' => '[2UZ5ij-e/dl4',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost/api/v1.0.0/reset-password'
payload = {
    "email": "qkunze@example.com",
    "otp": "consequatur",
    "password": "[2UZ5ij-e\/dl4"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_TOKEN}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Request      

POST api/v1.0.0/reset-password

Headers

Authorization        

Example: Bearer {YOUR_AUTH_TOKEN}

Content-Type        

Example: application/json

Accept        

Example: application/json

Body Parameters

email   string     

Must be a valid email address. Example: qkunze@example.com

otp   string     

Example: consequatur

password   string     

Must be at least 8 characters. Example: [2UZ5ij-e/dl4

GET api/v1.0.0/me

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1.0.0/me" \
    --header "Authorization: Bearer {YOUR_AUTH_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1.0.0/me"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1.0.0/me';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost/api/v1.0.0/me'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_TOKEN}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
vary: Origin
 

{
    "message": "Unauthenticated."
}

Request      

GET api/v1.0.0/me

Headers

Authorization        

Example: Bearer {YOUR_AUTH_TOKEN}

Content-Type        

Example: application/json

Accept        

Example: application/json

GET api/v1.0.0/logout

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1.0.0/logout" \
    --header "Authorization: Bearer {YOUR_AUTH_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1.0.0/logout"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1.0.0/logout';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost/api/v1.0.0/logout'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_TOKEN}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
vary: Origin
 

{
    "message": "Unauthenticated."
}

Request      

GET api/v1.0.0/logout

Headers

Authorization        

Example: Bearer {YOUR_AUTH_TOKEN}

Content-Type        

Example: application/json

Accept        

Example: application/json

POST api/v1.0.0/update-profile

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1.0.0/update-profile" \
    --header "Authorization: Bearer {YOUR_AUTH_TOKEN}" \
    --header "Content-Type: multipart/form-data" \
    --header "Accept: application/json" \
    --form "name=vmqeopfuudtdsufvyvddq"\
    --form "email=kunde.eloisa@example.com"\
    --form "new_password=hfqcoynlazghdtqtqxbajwbpilpmufinllwloauydlsmsjuryvojcybzvrbyickznkygloigmkw"\
    --form "photo=@C:\Users\user\AppData\Local\Temp\php80FF.tmp" 
const url = new URL(
    "http://localhost/api/v1.0.0/update-profile"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_TOKEN}",
    "Content-Type": "multipart/form-data",
    "Accept": "application/json",
};

const body = new FormData();
body.append('name', 'vmqeopfuudtdsufvyvddq');
body.append('email', 'kunde.eloisa@example.com');
body.append('new_password', 'hfqcoynlazghdtqtqxbajwbpilpmufinllwloauydlsmsjuryvojcybzvrbyickznkygloigmkw');
body.append('photo', document.querySelector('input[name="photo"]').files[0]);

fetch(url, {
    method: "POST",
    headers,
    body,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1.0.0/update-profile';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_TOKEN}',
            'Content-Type' => 'multipart/form-data',
            'Accept' => 'application/json',
        ],
        'multipart' => [
            [
                'name' => 'name',
                'contents' => 'vmqeopfuudtdsufvyvddq'
            ],
            [
                'name' => 'email',
                'contents' => 'kunde.eloisa@example.com'
            ],
            [
                'name' => 'new_password',
                'contents' => 'hfqcoynlazghdtqtqxbajwbpilpmufinllwloauydlsmsjuryvojcybzvrbyickznkygloigmkw'
            ],
            [
                'name' => 'photo',
                'contents' => fopen('C:\Users\user\AppData\Local\Temp\php80FF.tmp', 'r')
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost/api/v1.0.0/update-profile'
files = {
  'name': (None, 'vmqeopfuudtdsufvyvddq'),
  'email': (None, 'kunde.eloisa@example.com'),
  'new_password': (None, 'hfqcoynlazghdtqtqxbajwbpilpmufinllwloauydlsmsjuryvojcybzvrbyickznkygloigmkw'),
  'photo': open('C:\Users\user\AppData\Local\Temp\php80FF.tmp', 'rb')}
payload = {
    "name": "vmqeopfuudtdsufvyvddq",
    "email": "kunde.eloisa@example.com",
    "new_password": "hfqcoynlazghdtqtqxbajwbpilpmufinllwloauydlsmsjuryvojcybzvrbyickznkygloigmkw"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_TOKEN}',
  'Content-Type': 'multipart/form-data',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, files=files)
response.json()

Request      

POST api/v1.0.0/update-profile

Headers

Authorization        

Example: Bearer {YOUR_AUTH_TOKEN}

Content-Type        

Example: multipart/form-data

Accept        

Example: application/json

Body Parameters

name   string  optional    

Must not be greater than 255 characters. Example: vmqeopfuudtdsufvyvddq

email   string  optional    

Must be a valid email address. Must not be greater than 255 characters. Example: kunde.eloisa@example.com

photo   file  optional    

Must be an image. Must not be greater than 2048 kilobytes. Example: C:\Users\user\AppData\Local\Temp\php80FF.tmp

current_password   string  optional    

This field is required when new_password is present.

new_password   string  optional    

Must be at least 8 characters. Example: hfqcoynlazghdtqtqxbajwbpilpmufinllwloauydlsmsjuryvojcybzvrbyickznkygloigmkw

POST api/v1.0.0/register

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1.0.0/register" \
    --header "Authorization: Bearer {YOUR_AUTH_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"vmqeopfuudtdsufvyvddqamniihfqcoynlazghdtqtqxbajwbpilpmufinllwloauydlsmsjur\",
    \"email\": \"oschulist@example.org\",
    \"password\": \"z&~na%x\",
    \"passwordConfirm\": \"consequatur\",
    \"role\": \"enseignant\",
    \"first_name\": \"mqeopfuudtdsufvyvddqa\",
    \"last_name\": \"mniihfqcoynlazghdtqtq\",
    \"phone\": \"xbajwbpilpmufinll\",
    \"profession\": \"wloauydlsmsjuryvojcyb\",
    \"birth_date\": \"2025-12-11T12:03:27\"
}"

const url = new URL(
    "http://localhost/api/v1.0.0/register"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "vmqeopfuudtdsufvyvddqamniihfqcoynlazghdtqtqxbajwbpilpmufinllwloauydlsmsjur",
    "email": "oschulist@example.org",
    "password": "z&~na%x",
    "passwordConfirm": "consequatur",
    "role": "enseignant",
    "first_name": "mqeopfuudtdsufvyvddqa",
    "last_name": "mniihfqcoynlazghdtqtq",
    "phone": "xbajwbpilpmufinll",
    "profession": "wloauydlsmsjuryvojcyb",
    "birth_date": "2025-12-11T12:03:27"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1.0.0/register';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'vmqeopfuudtdsufvyvddqamniihfqcoynlazghdtqtqxbajwbpilpmufinllwloauydlsmsjur',
            'email' => 'oschulist@example.org',
            'password' => 'z&~na%x',
            'passwordConfirm' => 'consequatur',
            'role' => 'enseignant',
            'first_name' => 'mqeopfuudtdsufvyvddqa',
            'last_name' => 'mniihfqcoynlazghdtqtq',
            'phone' => 'xbajwbpilpmufinll',
            'profession' => 'wloauydlsmsjuryvojcyb',
            'birth_date' => '2025-12-11T12:03:27',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost/api/v1.0.0/register'
payload = {
    "name": "vmqeopfuudtdsufvyvddqamniihfqcoynlazghdtqtqxbajwbpilpmufinllwloauydlsmsjur",
    "email": "oschulist@example.org",
    "password": "z&~na%x",
    "passwordConfirm": "consequatur",
    "role": "enseignant",
    "first_name": "mqeopfuudtdsufvyvddqa",
    "last_name": "mniihfqcoynlazghdtqtq",
    "phone": "xbajwbpilpmufinll",
    "profession": "wloauydlsmsjuryvojcyb",
    "birth_date": "2025-12-11T12:03:27"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_TOKEN}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Request      

POST api/v1.0.0/register

Headers

Authorization        

Example: Bearer {YOUR_AUTH_TOKEN}

Content-Type        

Example: application/json

Accept        

Example: application/json

Body Parameters

name   string     

Must not be greater than 64 characters. Must be at least 4 characters. Example: vmqeopfuudtdsufvyvddqamniihfqcoynlazghdtqtqxbajwbpilpmufinllwloauydlsmsjur

email   string  optional    

Must be a valid email address. Must not be greater than 150 characters. Must be at least 4 characters. Example: oschulist@example.org

password   string     

Must be at least 8 characters. Example: z&~na%x

passwordConfirm   string     

The value and password must match. Example: consequatur

role   string     

Example: enseignant

Must be one of:
  • enseignant
  • directeur
first_name   string     

Must not be greater than 64 characters. Example: mqeopfuudtdsufvyvddqa

last_name   string     

Must not be greater than 64 characters. Example: mniihfqcoynlazghdtqtq

phone   string     

Must not be greater than 20 characters. Example: xbajwbpilpmufinll

profession   string     

Must not be greater than 128 characters. Example: wloauydlsmsjuryvojcyb

birth_date   string     

Must be a valid date. Example: 2025-12-11T12:03:27

GET api/v1.0.0/school-years/active

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1.0.0/school-years/active" \
    --header "Authorization: Bearer {YOUR_AUTH_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1.0.0/school-years/active"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1.0.0/school-years/active';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost/api/v1.0.0/school-years/active'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_TOKEN}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
vary: Origin
 

{
    "message": "Unauthenticated."
}

Request      

GET api/v1.0.0/school-years/active

Headers

Authorization        

Example: Bearer {YOUR_AUTH_TOKEN}

Content-Type        

Example: application/json

Accept        

Example: application/json

GET api/v1.0.0/school-years

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1.0.0/school-years" \
    --header "Authorization: Bearer {YOUR_AUTH_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1.0.0/school-years"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1.0.0/school-years';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost/api/v1.0.0/school-years'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_TOKEN}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
vary: Origin
 

{
    "message": "Unauthenticated."
}

Request      

GET api/v1.0.0/school-years

Headers

Authorization        

Example: Bearer {YOUR_AUTH_TOKEN}

Content-Type        

Example: application/json

Accept        

Example: application/json

GET api/v1.0.0/school-years/{id}

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1.0.0/school-years/1" \
    --header "Authorization: Bearer {YOUR_AUTH_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1.0.0/school-years/1"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1.0.0/school-years/1';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost/api/v1.0.0/school-years/1'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_TOKEN}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
vary: Origin
 

{
    "message": "Unauthenticated."
}

Request      

GET api/v1.0.0/school-years/{id}

Headers

Authorization        

Example: Bearer {YOUR_AUTH_TOKEN}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

id   integer     

The ID of the school year. Example: 1

GET api/v1.0.0/students

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1.0.0/students" \
    --header "Authorization: Bearer {YOUR_AUTH_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1.0.0/students"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1.0.0/students';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost/api/v1.0.0/students'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_TOKEN}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
vary: Origin
 

{
    "message": "Unauthenticated."
}

Request      

GET api/v1.0.0/students

Headers

Authorization        

Example: Bearer {YOUR_AUTH_TOKEN}

Content-Type        

Example: application/json

Accept        

Example: application/json

GET api/v1.0.0/students/{id}

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1.0.0/students/1" \
    --header "Authorization: Bearer {YOUR_AUTH_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1.0.0/students/1"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1.0.0/students/1';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost/api/v1.0.0/students/1'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_TOKEN}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
vary: Origin
 

{
    "message": "Unauthenticated."
}

Request      

GET api/v1.0.0/students/{id}

Headers

Authorization        

Example: Bearer {YOUR_AUTH_TOKEN}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

id   integer     

The ID of the student. Example: 1

Get student profile with enrollment history

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1.0.0/students/1/profile" \
    --header "Authorization: Bearer {YOUR_AUTH_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1.0.0/students/1/profile"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1.0.0/students/1/profile';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost/api/v1.0.0/students/1/profile'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_TOKEN}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
vary: Origin
 

{
    "message": "Unauthenticated."
}

Request      

GET api/v1.0.0/students/{student_id}/profile

Headers

Authorization        

Example: Bearer {YOUR_AUTH_TOKEN}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

student_id   integer     

The ID of the student. Example: 1

Get student grades for a specific school year

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1.0.0/students/1/grades" \
    --header "Authorization: Bearer {YOUR_AUTH_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1.0.0/students/1/grades"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1.0.0/students/1/grades';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost/api/v1.0.0/students/1/grades'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_TOKEN}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
vary: Origin
 

{
    "message": "Unauthenticated."
}

Request      

GET api/v1.0.0/students/{student_id}/grades

Headers

Authorization        

Example: Bearer {YOUR_AUTH_TOKEN}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

student_id   integer     

The ID of the student. Example: 1

Obtenir les détails complets d'un élève

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1.0.0/students/1/details" \
    --header "Authorization: Bearer {YOUR_AUTH_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1.0.0/students/1/details"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1.0.0/students/1/details';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost/api/v1.0.0/students/1/details'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_TOKEN}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
vary: Origin
 

{
    "message": "Unauthenticated."
}

Request      

GET api/v1.0.0/students/{student}/details

Headers

Authorization        

Example: Bearer {YOUR_AUTH_TOKEN}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

student   integer     

The student. Example: 1

Obtenir l'historique des inscriptions d'un élève

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1.0.0/students/1/enrollments" \
    --header "Authorization: Bearer {YOUR_AUTH_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1.0.0/students/1/enrollments"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1.0.0/students/1/enrollments';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost/api/v1.0.0/students/1/enrollments'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_TOKEN}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
vary: Origin
 

{
    "message": "Unauthenticated."
}

Request      

GET api/v1.0.0/students/{student}/enrollments

Headers

Authorization        

Example: Bearer {YOUR_AUTH_TOKEN}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

student   integer     

The student. Example: 1

Obtenir les examens d'un élève pour une année scolaire

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1.0.0/students/1/assignments" \
    --header "Authorization: Bearer {YOUR_AUTH_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1.0.0/students/1/assignments"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1.0.0/students/1/assignments';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost/api/v1.0.0/students/1/assignments'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_TOKEN}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
vary: Origin
 

{
    "message": "Unauthenticated."
}

Request      

GET api/v1.0.0/students/{student}/assignments

Headers

Authorization        

Example: Bearer {YOUR_AUTH_TOKEN}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

student   integer     

The student. Example: 1

List report cards for a student.

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1.0.0/students/1/report-cards" \
    --header "Authorization: Bearer {YOUR_AUTH_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1.0.0/students/1/report-cards"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1.0.0/students/1/report-cards';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost/api/v1.0.0/students/1/report-cards'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_TOKEN}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
vary: Origin
 

{
    "message": "Unauthenticated."
}

Request      

GET api/v1.0.0/students/{student}/report-cards

Headers

Authorization        

Example: Bearer {YOUR_AUTH_TOKEN}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

student   integer     

The student. Example: 1

Download the report card as PDF.

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1.0.0/report-cards/consequatur/download" \
    --header "Authorization: Bearer {YOUR_AUTH_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1.0.0/report-cards/consequatur/download"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1.0.0/report-cards/consequatur/download';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost/api/v1.0.0/report-cards/consequatur/download'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_TOKEN}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
vary: Origin
 

{
    "message": "Unauthenticated."
}

Request      

GET api/v1.0.0/report-cards/{reportCard}/download

Headers

Authorization        

Example: Bearer {YOUR_AUTH_TOKEN}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

reportCard   string     

Example: consequatur

GET api/v1.0.0/evaluation-types

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1.0.0/evaluation-types" \
    --header "Authorization: Bearer {YOUR_AUTH_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1.0.0/evaluation-types"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1.0.0/evaluation-types';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost/api/v1.0.0/evaluation-types'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_TOKEN}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
vary: Origin
 

{
    "message": "Unauthenticated."
}

Request      

GET api/v1.0.0/evaluation-types

Headers

Authorization        

Example: Bearer {YOUR_AUTH_TOKEN}

Content-Type        

Example: application/json

Accept        

Example: application/json

GET api/v1.0.0/grades

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1.0.0/grades" \
    --header "Authorization: Bearer {YOUR_AUTH_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1.0.0/grades"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1.0.0/grades';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost/api/v1.0.0/grades'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_TOKEN}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
vary: Origin
 

{
    "message": "Unauthenticated."
}

Request      

GET api/v1.0.0/grades

Headers

Authorization        

Example: Bearer {YOUR_AUTH_TOKEN}

Content-Type        

Example: application/json

Accept        

Example: application/json

POST api/v1.0.0/grades

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1.0.0/grades" \
    --header "Authorization: Bearer {YOUR_AUTH_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"student_id\": \"consequatur\",
    \"assignment_id\": \"consequatur\",
    \"score\": 45,
    \"notes\": \"qeopfuudtdsufvyvddqam\",
    \"graded_at\": \"2025-12-11T12:03:27\"
}"

const url = new URL(
    "http://localhost/api/v1.0.0/grades"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "student_id": "consequatur",
    "assignment_id": "consequatur",
    "score": 45,
    "notes": "qeopfuudtdsufvyvddqam",
    "graded_at": "2025-12-11T12:03:27"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1.0.0/grades';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'student_id' => 'consequatur',
            'assignment_id' => 'consequatur',
            'score' => 45,
            'notes' => 'qeopfuudtdsufvyvddqam',
            'graded_at' => '2025-12-11T12:03:27',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost/api/v1.0.0/grades'
payload = {
    "student_id": "consequatur",
    "assignment_id": "consequatur",
    "score": 45,
    "notes": "qeopfuudtdsufvyvddqam",
    "graded_at": "2025-12-11T12:03:27"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_TOKEN}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Request      

POST api/v1.0.0/grades

Headers

Authorization        

Example: Bearer {YOUR_AUTH_TOKEN}

Content-Type        

Example: application/json

Accept        

Example: application/json

Body Parameters

student_id   string     

The id of an existing record in the students table. Example: consequatur

assignment_id   string     

The id of an existing record in the assignments table. Example: consequatur

score   number     

Must be at least 0. Example: 45

notes   string  optional    

Must not be greater than 500 characters. Example: qeopfuudtdsufvyvddqam

graded_at   string  optional    

Must be a valid date. Example: 2025-12-11T12:03:27

GET api/v1.0.0/grades/{id}

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1.0.0/grades/1" \
    --header "Authorization: Bearer {YOUR_AUTH_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1.0.0/grades/1"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1.0.0/grades/1';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost/api/v1.0.0/grades/1'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_TOKEN}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
vary: Origin
 

{
    "message": "Unauthenticated."
}

Request      

GET api/v1.0.0/grades/{id}

Headers

Authorization        

Example: Bearer {YOUR_AUTH_TOKEN}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

id   integer     

The ID of the grade. Example: 1

GET api/v1.0.0/classrooms

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1.0.0/classrooms" \
    --header "Authorization: Bearer {YOUR_AUTH_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1.0.0/classrooms"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1.0.0/classrooms';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost/api/v1.0.0/classrooms'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_TOKEN}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
vary: Origin
 

{
    "message": "Unauthenticated."
}

Request      

GET api/v1.0.0/classrooms

Headers

Authorization        

Example: Bearer {YOUR_AUTH_TOKEN}

Content-Type        

Example: application/json

Accept        

Example: application/json

GET api/v1.0.0/classrooms/{id}

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1.0.0/classrooms/1" \
    --header "Authorization: Bearer {YOUR_AUTH_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1.0.0/classrooms/1"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1.0.0/classrooms/1';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost/api/v1.0.0/classrooms/1'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_TOKEN}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
vary: Origin
 

{
    "message": "Unauthenticated."
}

Request      

GET api/v1.0.0/classrooms/{id}

Headers

Authorization        

Example: Bearer {YOUR_AUTH_TOKEN}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

id   integer     

The ID of the classroom. Example: 1

Get students with ranking for a specific assignment/exam

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1.0.0/classrooms/1/ranking" \
    --header "Authorization: Bearer {YOUR_AUTH_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1.0.0/classrooms/1/ranking"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1.0.0/classrooms/1/ranking';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost/api/v1.0.0/classrooms/1/ranking'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_TOKEN}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
vary: Origin
 

{
    "message": "Unauthenticated."
}

Request      

GET api/v1.0.0/classrooms/{classroom_id}/ranking

Headers

Authorization        

Example: Bearer {YOUR_AUTH_TOKEN}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

classroom_id   integer     

The ID of the classroom. Example: 1

GET /classrooms/{classroom}/subjects?school_year_id=X Obtenir le programme d'une classe pour une année

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1.0.0/classrooms/1/subjects" \
    --header "Authorization: Bearer {YOUR_AUTH_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1.0.0/classrooms/1/subjects"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1.0.0/classrooms/1/subjects';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost/api/v1.0.0/classrooms/1/subjects'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_TOKEN}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
vary: Origin
 

{
    "message": "Unauthenticated."
}

Request      

GET api/v1.0.0/classrooms/{classroom_id}/subjects

Headers

Authorization        

Example: Bearer {YOUR_AUTH_TOKEN}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

classroom_id   integer     

The ID of the classroom. Example: 1

Obtenir les détails d'une classe avec ses élèves

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1.0.0/classrooms/1/details" \
    --header "Authorization: Bearer {YOUR_AUTH_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1.0.0/classrooms/1/details"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1.0.0/classrooms/1/details';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost/api/v1.0.0/classrooms/1/details'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_TOKEN}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
vary: Origin
 

{
    "message": "Unauthenticated."
}

Request      

GET api/v1.0.0/classrooms/{classroom}/details

Headers

Authorization        

Example: Bearer {YOUR_AUTH_TOKEN}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

classroom   integer     

The classroom. Example: 1

Liste des examens de la classe

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1.0.0/classrooms/1/assignments" \
    --header "Authorization: Bearer {YOUR_AUTH_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1.0.0/classrooms/1/assignments"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1.0.0/classrooms/1/assignments';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost/api/v1.0.0/classrooms/1/assignments'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_TOKEN}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
vary: Origin
 

{
    "message": "Unauthenticated."
}

Request      

GET api/v1.0.0/classrooms/{classroom}/assignments

Headers

Authorization        

Example: Bearer {YOUR_AUTH_TOKEN}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

classroom   integer     

The classroom. Example: 1

GET api/v1.0.0/teachers

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1.0.0/teachers" \
    --header "Authorization: Bearer {YOUR_AUTH_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1.0.0/teachers"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1.0.0/teachers';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost/api/v1.0.0/teachers'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_TOKEN}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
vary: Origin
 

{
    "message": "Unauthenticated."
}

Request      

GET api/v1.0.0/teachers

Headers

Authorization        

Example: Bearer {YOUR_AUTH_TOKEN}

Content-Type        

Example: application/json

Accept        

Example: application/json

GET api/v1.0.0/teachers/{id}

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1.0.0/teachers/1" \
    --header "Authorization: Bearer {YOUR_AUTH_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1.0.0/teachers/1"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1.0.0/teachers/1';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost/api/v1.0.0/teachers/1'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_TOKEN}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
vary: Origin
 

{
    "message": "Unauthenticated."
}

Request      

GET api/v1.0.0/teachers/{id}

Headers

Authorization        

Example: Bearer {YOUR_AUTH_TOKEN}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

id   integer     

The ID of the teacher. Example: 1

GET api/v1.0.0/subjects

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1.0.0/subjects" \
    --header "Authorization: Bearer {YOUR_AUTH_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1.0.0/subjects"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1.0.0/subjects';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost/api/v1.0.0/subjects'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_TOKEN}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
vary: Origin
 

{
    "message": "Unauthenticated."
}

Request      

GET api/v1.0.0/subjects

Headers

Authorization        

Example: Bearer {YOUR_AUTH_TOKEN}

Content-Type        

Example: application/json

Accept        

Example: application/json

GET api/v1.0.0/subjects/{id}

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1.0.0/subjects/1" \
    --header "Authorization: Bearer {YOUR_AUTH_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1.0.0/subjects/1"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1.0.0/subjects/1';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost/api/v1.0.0/subjects/1'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_TOKEN}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
vary: Origin
 

{
    "message": "Unauthenticated."
}

Request      

GET api/v1.0.0/subjects/{id}

Headers

Authorization        

Example: Bearer {YOUR_AUTH_TOKEN}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

id   integer     

The ID of the subject. Example: 1

GET api/v1.0.0/schedules

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1.0.0/schedules" \
    --header "Authorization: Bearer {YOUR_AUTH_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1.0.0/schedules"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1.0.0/schedules';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost/api/v1.0.0/schedules'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_TOKEN}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
vary: Origin
 

{
    "message": "Unauthenticated."
}

Request      

GET api/v1.0.0/schedules

Headers

Authorization        

Example: Bearer {YOUR_AUTH_TOKEN}

Content-Type        

Example: application/json

Accept        

Example: application/json

GET api/v1.0.0/schedules/{id}

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1.0.0/schedules/1" \
    --header "Authorization: Bearer {YOUR_AUTH_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1.0.0/schedules/1"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1.0.0/schedules/1';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost/api/v1.0.0/schedules/1'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_TOKEN}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
vary: Origin
 

{
    "message": "Unauthenticated."
}

Request      

GET api/v1.0.0/schedules/{id}

Headers

Authorization        

Example: Bearer {YOUR_AUTH_TOKEN}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

id   integer     

The ID of the schedule. Example: 1

GET api/v1.0.0/assignments

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1.0.0/assignments" \
    --header "Authorization: Bearer {YOUR_AUTH_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1.0.0/assignments"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1.0.0/assignments';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost/api/v1.0.0/assignments'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_TOKEN}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
vary: Origin
 

{
    "message": "Unauthenticated."
}

Request      

GET api/v1.0.0/assignments

Headers

Authorization        

Example: Bearer {YOUR_AUTH_TOKEN}

Content-Type        

Example: application/json

Accept        

Example: application/json

GET api/v1.0.0/assignments/{id}

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1.0.0/assignments/1" \
    --header "Authorization: Bearer {YOUR_AUTH_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1.0.0/assignments/1"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1.0.0/assignments/1';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost/api/v1.0.0/assignments/1'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_TOKEN}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
vary: Origin
 

{
    "message": "Unauthenticated."
}

Request      

GET api/v1.0.0/assignments/{id}

Headers

Authorization        

Example: Bearer {YOUR_AUTH_TOKEN}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

id   integer     

The ID of the assignment. Example: 1

GET api/v1.0.0/dashboard/stats

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1.0.0/dashboard/stats" \
    --header "Authorization: Bearer {YOUR_AUTH_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1.0.0/dashboard/stats"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1.0.0/dashboard/stats';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost/api/v1.0.0/dashboard/stats'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_TOKEN}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
vary: Origin
 

{
    "message": "Unauthenticated."
}

Request      

GET api/v1.0.0/dashboard/stats

Headers

Authorization        

Example: Bearer {YOUR_AUTH_TOKEN}

Content-Type        

Example: application/json

Accept        

Example: application/json

POST api/v1.0.0/students

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1.0.0/students" \
    --header "Authorization: Bearer {YOUR_AUTH_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"first_name\": \"vmqeopfuudtdsufvyvddq\",
    \"last_name\": \"amniihfqcoynlazghdtqt\",
    \"matricule\": \"qxbajwbpilpmufinllwlo\",
    \"birth_date\": \"2025-12-11T12:03:27\",
    \"gender\": \"M\",
    \"parent_contact\": \"auydlsmsjuryvojcybzvr\",
    \"address\": \"byickznkygloigmkwxphl\"
}"

const url = new URL(
    "http://localhost/api/v1.0.0/students"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "first_name": "vmqeopfuudtdsufvyvddq",
    "last_name": "amniihfqcoynlazghdtqt",
    "matricule": "qxbajwbpilpmufinllwlo",
    "birth_date": "2025-12-11T12:03:27",
    "gender": "M",
    "parent_contact": "auydlsmsjuryvojcybzvr",
    "address": "byickznkygloigmkwxphl"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1.0.0/students';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'first_name' => 'vmqeopfuudtdsufvyvddq',
            'last_name' => 'amniihfqcoynlazghdtqt',
            'matricule' => 'qxbajwbpilpmufinllwlo',
            'birth_date' => '2025-12-11T12:03:27',
            'gender' => 'M',
            'parent_contact' => 'auydlsmsjuryvojcybzvr',
            'address' => 'byickznkygloigmkwxphl',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost/api/v1.0.0/students'
payload = {
    "first_name": "vmqeopfuudtdsufvyvddq",
    "last_name": "amniihfqcoynlazghdtqt",
    "matricule": "qxbajwbpilpmufinllwlo",
    "birth_date": "2025-12-11T12:03:27",
    "gender": "M",
    "parent_contact": "auydlsmsjuryvojcybzvr",
    "address": "byickznkygloigmkwxphl"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_TOKEN}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Request      

POST api/v1.0.0/students

Headers

Authorization        

Example: Bearer {YOUR_AUTH_TOKEN}

Content-Type        

Example: application/json

Accept        

Example: application/json

Body Parameters

first_name   string     

Must not be greater than 100 characters. Example: vmqeopfuudtdsufvyvddq

last_name   string     

Must not be greater than 100 characters. Example: amniihfqcoynlazghdtqt

matricule   string     

Must not be greater than 50 characters. Example: qxbajwbpilpmufinllwlo

birth_date   string  optional    

Must be a valid date. Example: 2025-12-11T12:03:27

gender   string  optional    

Example: M

Must be one of:
  • M
  • F
parent_contact   string  optional    

Must not be greater than 100 characters. Example: auydlsmsjuryvojcybzvr

address   string  optional    

Must not be greater than 255 characters. Example: byickznkygloigmkwxphl

classroom_id   string  optional    

The id of an existing record in the classrooms table.

school_year_id   string  optional    

The id of an existing record in the school_years table.

school_id   string  optional    

The id of an existing record in the schools table.

PUT api/v1.0.0/students/{id}

requires authentication

Example request:
curl --request PUT \
    "http://localhost/api/v1.0.0/students/1" \
    --header "Authorization: Bearer {YOUR_AUTH_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"first_name\": \"vmqeopfuudtdsufvyvddq\",
    \"last_name\": \"amniihfqcoynlazghdtqt\",
    \"matricule\": \"qxbajwbpilpmufinllwlo\",
    \"birth_date\": \"2025-12-11T12:03:27\",
    \"gender\": \"M\",
    \"parent_contact\": \"auydlsmsjuryvojcybzvr\",
    \"address\": \"byickznkygloigmkwxphl\"
}"

const url = new URL(
    "http://localhost/api/v1.0.0/students/1"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "first_name": "vmqeopfuudtdsufvyvddq",
    "last_name": "amniihfqcoynlazghdtqt",
    "matricule": "qxbajwbpilpmufinllwlo",
    "birth_date": "2025-12-11T12:03:27",
    "gender": "M",
    "parent_contact": "auydlsmsjuryvojcybzvr",
    "address": "byickznkygloigmkwxphl"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1.0.0/students/1';
$response = $client->put(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'first_name' => 'vmqeopfuudtdsufvyvddq',
            'last_name' => 'amniihfqcoynlazghdtqt',
            'matricule' => 'qxbajwbpilpmufinllwlo',
            'birth_date' => '2025-12-11T12:03:27',
            'gender' => 'M',
            'parent_contact' => 'auydlsmsjuryvojcybzvr',
            'address' => 'byickznkygloigmkwxphl',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost/api/v1.0.0/students/1'
payload = {
    "first_name": "vmqeopfuudtdsufvyvddq",
    "last_name": "amniihfqcoynlazghdtqt",
    "matricule": "qxbajwbpilpmufinllwlo",
    "birth_date": "2025-12-11T12:03:27",
    "gender": "M",
    "parent_contact": "auydlsmsjuryvojcybzvr",
    "address": "byickznkygloigmkwxphl"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_TOKEN}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PUT', url, headers=headers, json=payload)
response.json()

Request      

PUT api/v1.0.0/students/{id}

PATCH api/v1.0.0/students/{id}

Headers

Authorization        

Example: Bearer {YOUR_AUTH_TOKEN}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

id   integer     

The ID of the student. Example: 1

Body Parameters

first_name   string  optional    

Must not be greater than 100 characters. Example: vmqeopfuudtdsufvyvddq

last_name   string  optional    

Must not be greater than 100 characters. Example: amniihfqcoynlazghdtqt

matricule   string  optional    

Must not be greater than 50 characters. Example: qxbajwbpilpmufinllwlo

birth_date   string  optional    

Must be a valid date. Example: 2025-12-11T12:03:27

gender   string  optional    

Example: M

Must be one of:
  • M
  • F
parent_contact   string  optional    

Must not be greater than 100 characters. Example: auydlsmsjuryvojcybzvr

address   string  optional    

Must not be greater than 255 characters. Example: byickznkygloigmkwxphl

DELETE api/v1.0.0/students/{id}

requires authentication

Example request:
curl --request DELETE \
    "http://localhost/api/v1.0.0/students/1" \
    --header "Authorization: Bearer {YOUR_AUTH_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1.0.0/students/1"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1.0.0/students/1';
$response = $client->delete(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost/api/v1.0.0/students/1'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_TOKEN}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Request      

DELETE api/v1.0.0/students/{id}

Headers

Authorization        

Example: Bearer {YOUR_AUTH_TOKEN}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

id   integer     

The ID of the student. Example: 1

POST api/v1.0.0/teachers

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1.0.0/teachers" \
    --header "Authorization: Bearer {YOUR_AUTH_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"first_name\": \"vmqeopfuudtdsufvyvddq\",
    \"last_name\": \"amniihfqcoynlazghdtqt\",
    \"phone\": \"qxbajwbpilpmufinl\",
    \"email\": \"imogene.mante@example.com\",
    \"specialization\": \"uydlsmsjuryvojcybzvrb\",
    \"birth_date\": \"2025-12-11T12:03:27\"
}"

const url = new URL(
    "http://localhost/api/v1.0.0/teachers"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "first_name": "vmqeopfuudtdsufvyvddq",
    "last_name": "amniihfqcoynlazghdtqt",
    "phone": "qxbajwbpilpmufinl",
    "email": "imogene.mante@example.com",
    "specialization": "uydlsmsjuryvojcybzvrb",
    "birth_date": "2025-12-11T12:03:27"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1.0.0/teachers';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'first_name' => 'vmqeopfuudtdsufvyvddq',
            'last_name' => 'amniihfqcoynlazghdtqt',
            'phone' => 'qxbajwbpilpmufinl',
            'email' => 'imogene.mante@example.com',
            'specialization' => 'uydlsmsjuryvojcybzvrb',
            'birth_date' => '2025-12-11T12:03:27',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost/api/v1.0.0/teachers'
payload = {
    "first_name": "vmqeopfuudtdsufvyvddq",
    "last_name": "amniihfqcoynlazghdtqt",
    "phone": "qxbajwbpilpmufinl",
    "email": "imogene.mante@example.com",
    "specialization": "uydlsmsjuryvojcybzvrb",
    "birth_date": "2025-12-11T12:03:27"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_TOKEN}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Request      

POST api/v1.0.0/teachers

Headers

Authorization        

Example: Bearer {YOUR_AUTH_TOKEN}

Content-Type        

Example: application/json

Accept        

Example: application/json

Body Parameters

first_name   string     

Must not be greater than 100 characters. Example: vmqeopfuudtdsufvyvddq

last_name   string     

Must not be greater than 100 characters. Example: amniihfqcoynlazghdtqt

phone   string  optional    

Must not be greater than 20 characters. Example: qxbajwbpilpmufinl

email   string  optional    

Must be a valid email address. Must not be greater than 255 characters. Example: imogene.mante@example.com

specialization   string  optional    

Must not be greater than 100 characters. Example: uydlsmsjuryvojcybzvrb

birth_date   string  optional    

Must be a valid date. Example: 2025-12-11T12:03:27

school_id   string  optional    

The id of an existing record in the schools table.

PUT api/v1.0.0/teachers/{id}

requires authentication

Example request:
curl --request PUT \
    "http://localhost/api/v1.0.0/teachers/1" \
    --header "Authorization: Bearer {YOUR_AUTH_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"first_name\": \"vmqeopfuudtdsufvyvddq\",
    \"last_name\": \"amniihfqcoynlazghdtqt\",
    \"phone\": \"qxbajwbpilpmufinl\",
    \"email\": \"imogene.mante@example.com\",
    \"specialization\": \"uydlsmsjuryvojcybzvrb\",
    \"birth_date\": \"2025-12-11T12:03:27\"
}"

const url = new URL(
    "http://localhost/api/v1.0.0/teachers/1"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "first_name": "vmqeopfuudtdsufvyvddq",
    "last_name": "amniihfqcoynlazghdtqt",
    "phone": "qxbajwbpilpmufinl",
    "email": "imogene.mante@example.com",
    "specialization": "uydlsmsjuryvojcybzvrb",
    "birth_date": "2025-12-11T12:03:27"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1.0.0/teachers/1';
$response = $client->put(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'first_name' => 'vmqeopfuudtdsufvyvddq',
            'last_name' => 'amniihfqcoynlazghdtqt',
            'phone' => 'qxbajwbpilpmufinl',
            'email' => 'imogene.mante@example.com',
            'specialization' => 'uydlsmsjuryvojcybzvrb',
            'birth_date' => '2025-12-11T12:03:27',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost/api/v1.0.0/teachers/1'
payload = {
    "first_name": "vmqeopfuudtdsufvyvddq",
    "last_name": "amniihfqcoynlazghdtqt",
    "phone": "qxbajwbpilpmufinl",
    "email": "imogene.mante@example.com",
    "specialization": "uydlsmsjuryvojcybzvrb",
    "birth_date": "2025-12-11T12:03:27"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_TOKEN}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PUT', url, headers=headers, json=payload)
response.json()

Request      

PUT api/v1.0.0/teachers/{id}

PATCH api/v1.0.0/teachers/{id}

Headers

Authorization        

Example: Bearer {YOUR_AUTH_TOKEN}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

id   integer     

The ID of the teacher. Example: 1

Body Parameters

first_name   string  optional    

Must not be greater than 100 characters. Example: vmqeopfuudtdsufvyvddq

last_name   string  optional    

Must not be greater than 100 characters. Example: amniihfqcoynlazghdtqt

phone   string  optional    

Must not be greater than 20 characters. Example: qxbajwbpilpmufinl

email   string  optional    

Must be a valid email address. Must not be greater than 255 characters. Example: imogene.mante@example.com

specialization   string  optional    

Must not be greater than 100 characters. Example: uydlsmsjuryvojcybzvrb

birth_date   string  optional    

Must be a valid date. Example: 2025-12-11T12:03:27

DELETE api/v1.0.0/teachers/{id}

requires authentication

Example request:
curl --request DELETE \
    "http://localhost/api/v1.0.0/teachers/1" \
    --header "Authorization: Bearer {YOUR_AUTH_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1.0.0/teachers/1"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1.0.0/teachers/1';
$response = $client->delete(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost/api/v1.0.0/teachers/1'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_TOKEN}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Request      

DELETE api/v1.0.0/teachers/{id}

Headers

Authorization        

Example: Bearer {YOUR_AUTH_TOKEN}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

id   integer     

The ID of the teacher. Example: 1

POST api/v1.0.0/subjects

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1.0.0/subjects" \
    --header "Authorization: Bearer {YOUR_AUTH_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"vmqeopfuudtdsufvyvddq\",
    \"code\": \"amniihfqcoynlazghdtqt\",
    \"coefficient\": 7
}"

const url = new URL(
    "http://localhost/api/v1.0.0/subjects"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "vmqeopfuudtdsufvyvddq",
    "code": "amniihfqcoynlazghdtqt",
    "coefficient": 7
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1.0.0/subjects';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'vmqeopfuudtdsufvyvddq',
            'code' => 'amniihfqcoynlazghdtqt',
            'coefficient' => 7,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost/api/v1.0.0/subjects'
payload = {
    "name": "vmqeopfuudtdsufvyvddq",
    "code": "amniihfqcoynlazghdtqt",
    "coefficient": 7
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_TOKEN}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Request      

POST api/v1.0.0/subjects

Headers

Authorization        

Example: Bearer {YOUR_AUTH_TOKEN}

Content-Type        

Example: application/json

Accept        

Example: application/json

Body Parameters

name   string     

Must not be greater than 100 characters. Example: vmqeopfuudtdsufvyvddq

code   string     

Must not be greater than 50 characters. Example: amniihfqcoynlazghdtqt

coefficient   number     

Must be at least 0. Must not be greater than 10. Example: 7

school_id   string  optional    

The id of an existing record in the schools table.

school_year_id   string  optional    

The id of an existing record in the school_years table.

PUT api/v1.0.0/subjects/{id}

requires authentication

Example request:
curl --request PUT \
    "http://localhost/api/v1.0.0/subjects/1" \
    --header "Authorization: Bearer {YOUR_AUTH_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"vmqeopfuudtdsufvyvddq\",
    \"code\": \"amniihfqcoynlazghdtqt\",
    \"coefficient\": 7
}"

const url = new URL(
    "http://localhost/api/v1.0.0/subjects/1"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "vmqeopfuudtdsufvyvddq",
    "code": "amniihfqcoynlazghdtqt",
    "coefficient": 7
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1.0.0/subjects/1';
$response = $client->put(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'vmqeopfuudtdsufvyvddq',
            'code' => 'amniihfqcoynlazghdtqt',
            'coefficient' => 7,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost/api/v1.0.0/subjects/1'
payload = {
    "name": "vmqeopfuudtdsufvyvddq",
    "code": "amniihfqcoynlazghdtqt",
    "coefficient": 7
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_TOKEN}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PUT', url, headers=headers, json=payload)
response.json()

Request      

PUT api/v1.0.0/subjects/{id}

PATCH api/v1.0.0/subjects/{id}

Headers

Authorization        

Example: Bearer {YOUR_AUTH_TOKEN}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

id   integer     

The ID of the subject. Example: 1

Body Parameters

name   string  optional    

Must not be greater than 100 characters. Example: vmqeopfuudtdsufvyvddq

code   string  optional    

Must not be greater than 50 characters. Example: amniihfqcoynlazghdtqt

coefficient   number     

Must be at least 0. Must not be greater than 10. Example: 7

school_year_id   string  optional    

The id of an existing record in the school_years table.

DELETE api/v1.0.0/subjects/{id}

requires authentication

Example request:
curl --request DELETE \
    "http://localhost/api/v1.0.0/subjects/1" \
    --header "Authorization: Bearer {YOUR_AUTH_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1.0.0/subjects/1"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1.0.0/subjects/1';
$response = $client->delete(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost/api/v1.0.0/subjects/1'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_TOKEN}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Request      

DELETE api/v1.0.0/subjects/{id}

Headers

Authorization        

Example: Bearer {YOUR_AUTH_TOKEN}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

id   integer     

The ID of the subject. Example: 1

POST api/v1.0.0/classrooms

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1.0.0/classrooms" \
    --header "Authorization: Bearer {YOUR_AUTH_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"vmqeopfuudtdsufvyvddq\",
    \"code\": \"amniihfqcoynlazghdtqt\",
    \"cycle\": \"primaire\",
    \"level\": \"qxbajwbpilpmufinllwlo\",
    \"tuition_fee\": 2,
    \"school_year_id\": \"consequatur\"
}"

const url = new URL(
    "http://localhost/api/v1.0.0/classrooms"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "vmqeopfuudtdsufvyvddq",
    "code": "amniihfqcoynlazghdtqt",
    "cycle": "primaire",
    "level": "qxbajwbpilpmufinllwlo",
    "tuition_fee": 2,
    "school_year_id": "consequatur"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1.0.0/classrooms';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'vmqeopfuudtdsufvyvddq',
            'code' => 'amniihfqcoynlazghdtqt',
            'cycle' => 'primaire',
            'level' => 'qxbajwbpilpmufinllwlo',
            'tuition_fee' => 2,
            'school_year_id' => 'consequatur',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost/api/v1.0.0/classrooms'
payload = {
    "name": "vmqeopfuudtdsufvyvddq",
    "code": "amniihfqcoynlazghdtqt",
    "cycle": "primaire",
    "level": "qxbajwbpilpmufinllwlo",
    "tuition_fee": 2,
    "school_year_id": "consequatur"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_TOKEN}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Request      

POST api/v1.0.0/classrooms

Headers

Authorization        

Example: Bearer {YOUR_AUTH_TOKEN}

Content-Type        

Example: application/json

Accept        

Example: application/json

Body Parameters

name   string     

Must not be greater than 100 characters. Example: vmqeopfuudtdsufvyvddq

code   string     

Must not be greater than 50 characters. Example: amniihfqcoynlazghdtqt

cycle   string     

Example: primaire

Must be one of:
  • primaire
  • college
  • lycee
level   string     

Must not be greater than 50 characters. Example: qxbajwbpilpmufinllwlo

tuition_fee   number  optional    

Must be at least 0. Example: 2

school_year_id   string     

The id of an existing record in the school_years table. Example: consequatur

school_id   string  optional    

The id of an existing record in the schools table.

PUT api/v1.0.0/classrooms/{id}

requires authentication

Example request:
curl --request PUT \
    "http://localhost/api/v1.0.0/classrooms/1" \
    --header "Authorization: Bearer {YOUR_AUTH_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"vmqeopfuudtdsufvyvddq\",
    \"code\": \"amniihfqcoynlazghdtqt\",
    \"cycle\": \"college\",
    \"level\": \"qxbajwbpilpmufinllwlo\",
    \"tuition_fee\": 2
}"

const url = new URL(
    "http://localhost/api/v1.0.0/classrooms/1"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "vmqeopfuudtdsufvyvddq",
    "code": "amniihfqcoynlazghdtqt",
    "cycle": "college",
    "level": "qxbajwbpilpmufinllwlo",
    "tuition_fee": 2
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1.0.0/classrooms/1';
$response = $client->put(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'vmqeopfuudtdsufvyvddq',
            'code' => 'amniihfqcoynlazghdtqt',
            'cycle' => 'college',
            'level' => 'qxbajwbpilpmufinllwlo',
            'tuition_fee' => 2,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost/api/v1.0.0/classrooms/1'
payload = {
    "name": "vmqeopfuudtdsufvyvddq",
    "code": "amniihfqcoynlazghdtqt",
    "cycle": "college",
    "level": "qxbajwbpilpmufinllwlo",
    "tuition_fee": 2
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_TOKEN}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PUT', url, headers=headers, json=payload)
response.json()

Request      

PUT api/v1.0.0/classrooms/{id}

PATCH api/v1.0.0/classrooms/{id}

Headers

Authorization        

Example: Bearer {YOUR_AUTH_TOKEN}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

id   integer     

The ID of the classroom. Example: 1

Body Parameters

name   string  optional    

Must not be greater than 100 characters. Example: vmqeopfuudtdsufvyvddq

code   string  optional    

Must not be greater than 50 characters. Example: amniihfqcoynlazghdtqt

cycle   string  optional    

Example: college

Must be one of:
  • primaire
  • college
  • lycee
level   string  optional    

Must not be greater than 50 characters. Example: qxbajwbpilpmufinllwlo

tuition_fee   number  optional    

Must be at least 0. Example: 2

DELETE api/v1.0.0/classrooms/{id}

requires authentication

Example request:
curl --request DELETE \
    "http://localhost/api/v1.0.0/classrooms/1" \
    --header "Authorization: Bearer {YOUR_AUTH_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1.0.0/classrooms/1"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1.0.0/classrooms/1';
$response = $client->delete(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost/api/v1.0.0/classrooms/1'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_TOKEN}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Request      

DELETE api/v1.0.0/classrooms/{id}

Headers

Authorization        

Example: Bearer {YOUR_AUTH_TOKEN}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

id   integer     

The ID of the classroom. Example: 1

POST api/v1.0.0/school-years

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1.0.0/school-years" \
    --header "Authorization: Bearer {YOUR_AUTH_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"year_start\": \"vmqeopfuudtdsufvyvddqamniihfqcoynlazghdtqtqxbajwbpilpmufinllwloauydlsmsjuryvojcybzvrbyickznkygloigmkwxphlvazjrcnfbaqywuxhgjjmzuxjubqouzswiwxtrkimfcatbxspzmrazsroyjpxmqesedyghenqcopwvownkbamlnfngefbeilfzsyuxoezbdtabptcyyerevrljcbwkthjnescwsestcouxpqsydkigioyoyprjkfdjsneawgaavuiwlezlcraoooxrrjhbduowtbaqrrtgxiuvujtzcirplnfqsaymxpayeblqozckazplqjijwkuzgpjfumffsmqnmbekhsobzoqisjmbiuqxdnvttnwpjqkxxmutyzaadbjkbosusobdoqhlrecwgwnfrnqkqzoekemczcjkacxowxjfjhqnumftkwbfqsgaywjxhjqovkxzlvalyuwppfckszbujxazwsrqgzomzeowirvzubjxoeqxihgafndjgiswmddoraronrpbzlovdmbhrpyvkublvfopexlamadlsacjsrgesfcxzbqmrckwedjrwdsuajoeoqmqffvhmzauptsfvjrmcalgbthdntpexwxxdiyobdrslnocxxyqedhjzawnzhdqlunbdokxinubiizcohftgbflwjgmdatxmhncusavwtslayrzreqabfecuwjcoloukrlzvlbbmxthelswnqevtlyttcalavphnvhrmgqxswjgeyzvkwswetvavnnocttofmmugtmzmckfrakhdsnuzlhcpgqgalgsyyfotqcgafnobbhncyxqyuffvcqbyumpwrlumwxxdyqedhfeounhryjgaxneystliyjooovyibymvjnwhumoxehubcitbhkwaryopzlpbwlfyzvokqfxowxdeqxewukvqkwoayysgiaxtksynryxlhpwigcfxcafzorqpzjxqnwrgmtowxlnxtkzsiwnlrihnbxrequetmqfdzbjkyriyjueelxazabzonzhqtcexnmfejczmupvoqzpkdrjekvlkhoowefmklkvxaknsbvvujgxkqrgbpqrqflnookmimjkkkprdcjyywrqmztqyrcitrxxhcqvvljacyxyminwtwhgqrtzuraksqbrwkyokhllyzjdyippspohjmaiqpeamxiksaufmlcuekigtakygfulkzczuevuzriduxdjkkhevfmaxupuxjitippyebnlntnuywmfxgnvshwkcwnkohvlzodznxrawslybajwsqrczenkqygqluzfyjatuksndxeskwuwxxdvjnkjkdcibylppyndjzjdgfiqvxhbpefryqufgnqlwehrioparcarjehnlendrjdqneewrvbbyopsilxbicbissggtkylynczyzdfucntzxrthfhocwuqewskybgpibdxosjianczphykhlpfhezifloprigaqqhjsuxudvmrgphuroknmwxkgueazqpuecrzpbafpbcyxphvwrfcxhvsutefsqakmbodshvjihubyieyqyhpmofdcwjzffhitvsyesnxesgmovjgtrwiblmybwxojjqnh\",
    \"year_end\": \"8107\",
    \"label\": \"mqeopfuudtdsufvyvddqa\",
    \"is_active\": true,
    \"start_date\": \"2025-12-11T12:03:27\",
    \"end_date\": \"2107-01-10\"
}"

const url = new URL(
    "http://localhost/api/v1.0.0/school-years"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "year_start": "vmqeopfuudtdsufvyvddqamniihfqcoynlazghdtqtqxbajwbpilpmufinllwloauydlsmsjuryvojcybzvrbyickznkygloigmkwxphlvazjrcnfbaqywuxhgjjmzuxjubqouzswiwxtrkimfcatbxspzmrazsroyjpxmqesedyghenqcopwvownkbamlnfngefbeilfzsyuxoezbdtabptcyyerevrljcbwkthjnescwsestcouxpqsydkigioyoyprjkfdjsneawgaavuiwlezlcraoooxrrjhbduowtbaqrrtgxiuvujtzcirplnfqsaymxpayeblqozckazplqjijwkuzgpjfumffsmqnmbekhsobzoqisjmbiuqxdnvttnwpjqkxxmutyzaadbjkbosusobdoqhlrecwgwnfrnqkqzoekemczcjkacxowxjfjhqnumftkwbfqsgaywjxhjqovkxzlvalyuwppfckszbujxazwsrqgzomzeowirvzubjxoeqxihgafndjgiswmddoraronrpbzlovdmbhrpyvkublvfopexlamadlsacjsrgesfcxzbqmrckwedjrwdsuajoeoqmqffvhmzauptsfvjrmcalgbthdntpexwxxdiyobdrslnocxxyqedhjzawnzhdqlunbdokxinubiizcohftgbflwjgmdatxmhncusavwtslayrzreqabfecuwjcoloukrlzvlbbmxthelswnqevtlyttcalavphnvhrmgqxswjgeyzvkwswetvavnnocttofmmugtmzmckfrakhdsnuzlhcpgqgalgsyyfotqcgafnobbhncyxqyuffvcqbyumpwrlumwxxdyqedhfeounhryjgaxneystliyjooovyibymvjnwhumoxehubcitbhkwaryopzlpbwlfyzvokqfxowxdeqxewukvqkwoayysgiaxtksynryxlhpwigcfxcafzorqpzjxqnwrgmtowxlnxtkzsiwnlrihnbxrequetmqfdzbjkyriyjueelxazabzonzhqtcexnmfejczmupvoqzpkdrjekvlkhoowefmklkvxaknsbvvujgxkqrgbpqrqflnookmimjkkkprdcjyywrqmztqyrcitrxxhcqvvljacyxyminwtwhgqrtzuraksqbrwkyokhllyzjdyippspohjmaiqpeamxiksaufmlcuekigtakygfulkzczuevuzriduxdjkkhevfmaxupuxjitippyebnlntnuywmfxgnvshwkcwnkohvlzodznxrawslybajwsqrczenkqygqluzfyjatuksndxeskwuwxxdvjnkjkdcibylppyndjzjdgfiqvxhbpefryqufgnqlwehrioparcarjehnlendrjdqneewrvbbyopsilxbicbissggtkylynczyzdfucntzxrthfhocwuqewskybgpibdxosjianczphykhlpfhezifloprigaqqhjsuxudvmrgphuroknmwxkgueazqpuecrzpbafpbcyxphvwrfcxhvsutefsqakmbodshvjihubyieyqyhpmofdcwjzffhitvsyesnxesgmovjgtrwiblmybwxojjqnh",
    "year_end": "8107",
    "label": "mqeopfuudtdsufvyvddqa",
    "is_active": true,
    "start_date": "2025-12-11T12:03:27",
    "end_date": "2107-01-10"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1.0.0/school-years';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'year_start' => 'vmqeopfuudtdsufvyvddqamniihfqcoynlazghdtqtqxbajwbpilpmufinllwloauydlsmsjuryvojcybzvrbyickznkygloigmkwxphlvazjrcnfbaqywuxhgjjmzuxjubqouzswiwxtrkimfcatbxspzmrazsroyjpxmqesedyghenqcopwvownkbamlnfngefbeilfzsyuxoezbdtabptcyyerevrljcbwkthjnescwsestcouxpqsydkigioyoyprjkfdjsneawgaavuiwlezlcraoooxrrjhbduowtbaqrrtgxiuvujtzcirplnfqsaymxpayeblqozckazplqjijwkuzgpjfumffsmqnmbekhsobzoqisjmbiuqxdnvttnwpjqkxxmutyzaadbjkbosusobdoqhlrecwgwnfrnqkqzoekemczcjkacxowxjfjhqnumftkwbfqsgaywjxhjqovkxzlvalyuwppfckszbujxazwsrqgzomzeowirvzubjxoeqxihgafndjgiswmddoraronrpbzlovdmbhrpyvkublvfopexlamadlsacjsrgesfcxzbqmrckwedjrwdsuajoeoqmqffvhmzauptsfvjrmcalgbthdntpexwxxdiyobdrslnocxxyqedhjzawnzhdqlunbdokxinubiizcohftgbflwjgmdatxmhncusavwtslayrzreqabfecuwjcoloukrlzvlbbmxthelswnqevtlyttcalavphnvhrmgqxswjgeyzvkwswetvavnnocttofmmugtmzmckfrakhdsnuzlhcpgqgalgsyyfotqcgafnobbhncyxqyuffvcqbyumpwrlumwxxdyqedhfeounhryjgaxneystliyjooovyibymvjnwhumoxehubcitbhkwaryopzlpbwlfyzvokqfxowxdeqxewukvqkwoayysgiaxtksynryxlhpwigcfxcafzorqpzjxqnwrgmtowxlnxtkzsiwnlrihnbxrequetmqfdzbjkyriyjueelxazabzonzhqtcexnmfejczmupvoqzpkdrjekvlkhoowefmklkvxaknsbvvujgxkqrgbpqrqflnookmimjkkkprdcjyywrqmztqyrcitrxxhcqvvljacyxyminwtwhgqrtzuraksqbrwkyokhllyzjdyippspohjmaiqpeamxiksaufmlcuekigtakygfulkzczuevuzriduxdjkkhevfmaxupuxjitippyebnlntnuywmfxgnvshwkcwnkohvlzodznxrawslybajwsqrczenkqygqluzfyjatuksndxeskwuwxxdvjnkjkdcibylppyndjzjdgfiqvxhbpefryqufgnqlwehrioparcarjehnlendrjdqneewrvbbyopsilxbicbissggtkylynczyzdfucntzxrthfhocwuqewskybgpibdxosjianczphykhlpfhezifloprigaqqhjsuxudvmrgphuroknmwxkgueazqpuecrzpbafpbcyxphvwrfcxhvsutefsqakmbodshvjihubyieyqyhpmofdcwjzffhitvsyesnxesgmovjgtrwiblmybwxojjqnh',
            'year_end' => '8107',
            'label' => 'mqeopfuudtdsufvyvddqa',
            'is_active' => true,
            'start_date' => '2025-12-11T12:03:27',
            'end_date' => '2107-01-10',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost/api/v1.0.0/school-years'
payload = {
    "year_start": "vmqeopfuudtdsufvyvddqamniihfqcoynlazghdtqtqxbajwbpilpmufinllwloauydlsmsjuryvojcybzvrbyickznkygloigmkwxphlvazjrcnfbaqywuxhgjjmzuxjubqouzswiwxtrkimfcatbxspzmrazsroyjpxmqesedyghenqcopwvownkbamlnfngefbeilfzsyuxoezbdtabptcyyerevrljcbwkthjnescwsestcouxpqsydkigioyoyprjkfdjsneawgaavuiwlezlcraoooxrrjhbduowtbaqrrtgxiuvujtzcirplnfqsaymxpayeblqozckazplqjijwkuzgpjfumffsmqnmbekhsobzoqisjmbiuqxdnvttnwpjqkxxmutyzaadbjkbosusobdoqhlrecwgwnfrnqkqzoekemczcjkacxowxjfjhqnumftkwbfqsgaywjxhjqovkxzlvalyuwppfckszbujxazwsrqgzomzeowirvzubjxoeqxihgafndjgiswmddoraronrpbzlovdmbhrpyvkublvfopexlamadlsacjsrgesfcxzbqmrckwedjrwdsuajoeoqmqffvhmzauptsfvjrmcalgbthdntpexwxxdiyobdrslnocxxyqedhjzawnzhdqlunbdokxinubiizcohftgbflwjgmdatxmhncusavwtslayrzreqabfecuwjcoloukrlzvlbbmxthelswnqevtlyttcalavphnvhrmgqxswjgeyzvkwswetvavnnocttofmmugtmzmckfrakhdsnuzlhcpgqgalgsyyfotqcgafnobbhncyxqyuffvcqbyumpwrlumwxxdyqedhfeounhryjgaxneystliyjooovyibymvjnwhumoxehubcitbhkwaryopzlpbwlfyzvokqfxowxdeqxewukvqkwoayysgiaxtksynryxlhpwigcfxcafzorqpzjxqnwrgmtowxlnxtkzsiwnlrihnbxrequetmqfdzbjkyriyjueelxazabzonzhqtcexnmfejczmupvoqzpkdrjekvlkhoowefmklkvxaknsbvvujgxkqrgbpqrqflnookmimjkkkprdcjyywrqmztqyrcitrxxhcqvvljacyxyminwtwhgqrtzuraksqbrwkyokhllyzjdyippspohjmaiqpeamxiksaufmlcuekigtakygfulkzczuevuzriduxdjkkhevfmaxupuxjitippyebnlntnuywmfxgnvshwkcwnkohvlzodznxrawslybajwsqrczenkqygqluzfyjatuksndxeskwuwxxdvjnkjkdcibylppyndjzjdgfiqvxhbpefryqufgnqlwehrioparcarjehnlendrjdqneewrvbbyopsilxbicbissggtkylynczyzdfucntzxrthfhocwuqewskybgpibdxosjianczphykhlpfhezifloprigaqqhjsuxudvmrgphuroknmwxkgueazqpuecrzpbafpbcyxphvwrfcxhvsutefsqakmbodshvjihubyieyqyhpmofdcwjzffhitvsyesnxesgmovjgtrwiblmybwxojjqnh",
    "year_end": "8107",
    "label": "mqeopfuudtdsufvyvddqa",
    "is_active": true,
    "start_date": "2025-12-11T12:03:27",
    "end_date": "2107-01-10"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_TOKEN}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Request      

POST api/v1.0.0/school-years

Headers

Authorization        

Example: Bearer {YOUR_AUTH_TOKEN}

Content-Type        

Example: application/json

Accept        

Example: application/json

Body Parameters

year_start   string     

Must be 4 digits. Must be at least 2000 characters. Example: vmqeopfuudtdsufvyvddqamniihfqcoynlazghdtqtqxbajwbpilpmufinllwloauydlsmsjuryvojcybzvrbyickznkygloigmkwxphlvazjrcnfbaqywuxhgjjmzuxjubqouzswiwxtrkimfcatbxspzmrazsroyjpxmqesedyghenqcopwvownkbamlnfngefbeilfzsyuxoezbdtabptcyyerevrljcbwkthjnescwsestcouxpqsydkigioyoyprjkfdjsneawgaavuiwlezlcraoooxrrjhbduowtbaqrrtgxiuvujtzcirplnfqsaymxpayeblqozckazplqjijwkuzgpjfumffsmqnmbekhsobzoqisjmbiuqxdnvttnwpjqkxxmutyzaadbjkbosusobdoqhlrecwgwnfrnqkqzoekemczcjkacxowxjfjhqnumftkwbfqsgaywjxhjqovkxzlvalyuwppfckszbujxazwsrqgzomzeowirvzubjxoeqxihgafndjgiswmddoraronrpbzlovdmbhrpyvkublvfopexlamadlsacjsrgesfcxzbqmrckwedjrwdsuajoeoqmqffvhmzauptsfvjrmcalgbthdntpexwxxdiyobdrslnocxxyqedhjzawnzhdqlunbdokxinubiizcohftgbflwjgmdatxmhncusavwtslayrzreqabfecuwjcoloukrlzvlbbmxthelswnqevtlyttcalavphnvhrmgqxswjgeyzvkwswetvavnnocttofmmugtmzmckfrakhdsnuzlhcpgqgalgsyyfotqcgafnobbhncyxqyuffvcqbyumpwrlumwxxdyqedhfeounhryjgaxneystliyjooovyibymvjnwhumoxehubcitbhkwaryopzlpbwlfyzvokqfxowxdeqxewukvqkwoayysgiaxtksynryxlhpwigcfxcafzorqpzjxqnwrgmtowxlnxtkzsiwnlrihnbxrequetmqfdzbjkyriyjueelxazabzonzhqtcexnmfejczmupvoqzpkdrjekvlkhoowefmklkvxaknsbvvujgxkqrgbpqrqflnookmimjkkkprdcjyywrqmztqyrcitrxxhcqvvljacyxyminwtwhgqrtzuraksqbrwkyokhllyzjdyippspohjmaiqpeamxiksaufmlcuekigtakygfulkzczuevuzriduxdjkkhevfmaxupuxjitippyebnlntnuywmfxgnvshwkcwnkohvlzodznxrawslybajwsqrczenkqygqluzfyjatuksndxeskwuwxxdvjnkjkdcibylppyndjzjdgfiqvxhbpefryqufgnqlwehrioparcarjehnlendrjdqneewrvbbyopsilxbicbissggtkylynczyzdfucntzxrthfhocwuqewskybgpibdxosjianczphykhlpfhezifloprigaqqhjsuxudvmrgphuroknmwxkgueazqpuecrzpbafpbcyxphvwrfcxhvsutefsqakmbodshvjihubyieyqyhpmofdcwjzffhitvsyesnxesgmovjgtrwiblmybwxojjqnh

year_end   string     

Must be 4 digits. Example: 8107

label   string     

Must not be greater than 100 characters. Example: mqeopfuudtdsufvyvddqa

is_active   boolean  optional    

Example: true

start_date   string  optional    

Must be a valid date. Example: 2025-12-11T12:03:27

end_date   string  optional    

Must be a valid date. Must be a date after or equal to start_date. Example: 2107-01-10

school_id   string  optional    

The id of an existing record in the schools table.

PUT api/v1.0.0/school-years/{id}

requires authentication

Example request:
curl --request PUT \
    "http://localhost/api/v1.0.0/school-years/1" \
    --header "Authorization: Bearer {YOUR_AUTH_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"year_start\": \"vmqeopfuudtdsufvyvddqamniihfqcoynlazghdtqtqxbajwbpilpmufinllwloauydlsmsjuryvojcybzvrbyickznkygloigmkwxphlvazjrcnfbaqywuxhgjjmzuxjubqouzswiwxtrkimfcatbxspzmrazsroyjpxmqesedyghenqcopwvownkbamlnfngefbeilfzsyuxoezbdtabptcyyerevrljcbwkthjnescwsestcouxpqsydkigioyoyprjkfdjsneawgaavuiwlezlcraoooxrrjhbduowtbaqrrtgxiuvujtzcirplnfqsaymxpayeblqozckazplqjijwkuzgpjfumffsmqnmbekhsobzoqisjmbiuqxdnvttnwpjqkxxmutyzaadbjkbosusobdoqhlrecwgwnfrnqkqzoekemczcjkacxowxjfjhqnumftkwbfqsgaywjxhjqovkxzlvalyuwppfckszbujxazwsrqgzomzeowirvzubjxoeqxihgafndjgiswmddoraronrpbzlovdmbhrpyvkublvfopexlamadlsacjsrgesfcxzbqmrckwedjrwdsuajoeoqmqffvhmzauptsfvjrmcalgbthdntpexwxxdiyobdrslnocxxyqedhjzawnzhdqlunbdokxinubiizcohftgbflwjgmdatxmhncusavwtslayrzreqabfecuwjcoloukrlzvlbbmxthelswnqevtlyttcalavphnvhrmgqxswjgeyzvkwswetvavnnocttofmmugtmzmckfrakhdsnuzlhcpgqgalgsyyfotqcgafnobbhncyxqyuffvcqbyumpwrlumwxxdyqedhfeounhryjgaxneystliyjooovyibymvjnwhumoxehubcitbhkwaryopzlpbwlfyzvokqfxowxdeqxewukvqkwoayysgiaxtksynryxlhpwigcfxcafzorqpzjxqnwrgmtowxlnxtkzsiwnlrihnbxrequetmqfdzbjkyriyjueelxazabzonzhqtcexnmfejczmupvoqzpkdrjekvlkhoowefmklkvxaknsbvvujgxkqrgbpqrqflnookmimjkkkprdcjyywrqmztqyrcitrxxhcqvvljacyxyminwtwhgqrtzuraksqbrwkyokhllyzjdyippspohjmaiqpeamxiksaufmlcuekigtakygfulkzczuevuzriduxdjkkhevfmaxupuxjitippyebnlntnuywmfxgnvshwkcwnkohvlzodznxrawslybajwsqrczenkqygqluzfyjatuksndxeskwuwxxdvjnkjkdcibylppyndjzjdgfiqvxhbpefryqufgnqlwehrioparcarjehnlendrjdqneewrvbbyopsilxbicbissggtkylynczyzdfucntzxrthfhocwuqewskybgpibdxosjianczphykhlpfhezifloprigaqqhjsuxudvmrgphuroknmwxkgueazqpuecrzpbafpbcyxphvwrfcxhvsutefsqakmbodshvjihubyieyqyhpmofdcwjzffhitvsyesnxesgmovjgtrwiblmybwxojjqnh\",
    \"year_end\": \"8107\",
    \"label\": \"mqeopfuudtdsufvyvddqa\",
    \"is_active\": false,
    \"start_date\": \"2025-12-11T12:03:27\",
    \"end_date\": \"2107-01-10\"
}"

const url = new URL(
    "http://localhost/api/v1.0.0/school-years/1"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "year_start": "vmqeopfuudtdsufvyvddqamniihfqcoynlazghdtqtqxbajwbpilpmufinllwloauydlsmsjuryvojcybzvrbyickznkygloigmkwxphlvazjrcnfbaqywuxhgjjmzuxjubqouzswiwxtrkimfcatbxspzmrazsroyjpxmqesedyghenqcopwvownkbamlnfngefbeilfzsyuxoezbdtabptcyyerevrljcbwkthjnescwsestcouxpqsydkigioyoyprjkfdjsneawgaavuiwlezlcraoooxrrjhbduowtbaqrrtgxiuvujtzcirplnfqsaymxpayeblqozckazplqjijwkuzgpjfumffsmqnmbekhsobzoqisjmbiuqxdnvttnwpjqkxxmutyzaadbjkbosusobdoqhlrecwgwnfrnqkqzoekemczcjkacxowxjfjhqnumftkwbfqsgaywjxhjqovkxzlvalyuwppfckszbujxazwsrqgzomzeowirvzubjxoeqxihgafndjgiswmddoraronrpbzlovdmbhrpyvkublvfopexlamadlsacjsrgesfcxzbqmrckwedjrwdsuajoeoqmqffvhmzauptsfvjrmcalgbthdntpexwxxdiyobdrslnocxxyqedhjzawnzhdqlunbdokxinubiizcohftgbflwjgmdatxmhncusavwtslayrzreqabfecuwjcoloukrlzvlbbmxthelswnqevtlyttcalavphnvhrmgqxswjgeyzvkwswetvavnnocttofmmugtmzmckfrakhdsnuzlhcpgqgalgsyyfotqcgafnobbhncyxqyuffvcqbyumpwrlumwxxdyqedhfeounhryjgaxneystliyjooovyibymvjnwhumoxehubcitbhkwaryopzlpbwlfyzvokqfxowxdeqxewukvqkwoayysgiaxtksynryxlhpwigcfxcafzorqpzjxqnwrgmtowxlnxtkzsiwnlrihnbxrequetmqfdzbjkyriyjueelxazabzonzhqtcexnmfejczmupvoqzpkdrjekvlkhoowefmklkvxaknsbvvujgxkqrgbpqrqflnookmimjkkkprdcjyywrqmztqyrcitrxxhcqvvljacyxyminwtwhgqrtzuraksqbrwkyokhllyzjdyippspohjmaiqpeamxiksaufmlcuekigtakygfulkzczuevuzriduxdjkkhevfmaxupuxjitippyebnlntnuywmfxgnvshwkcwnkohvlzodznxrawslybajwsqrczenkqygqluzfyjatuksndxeskwuwxxdvjnkjkdcibylppyndjzjdgfiqvxhbpefryqufgnqlwehrioparcarjehnlendrjdqneewrvbbyopsilxbicbissggtkylynczyzdfucntzxrthfhocwuqewskybgpibdxosjianczphykhlpfhezifloprigaqqhjsuxudvmrgphuroknmwxkgueazqpuecrzpbafpbcyxphvwrfcxhvsutefsqakmbodshvjihubyieyqyhpmofdcwjzffhitvsyesnxesgmovjgtrwiblmybwxojjqnh",
    "year_end": "8107",
    "label": "mqeopfuudtdsufvyvddqa",
    "is_active": false,
    "start_date": "2025-12-11T12:03:27",
    "end_date": "2107-01-10"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1.0.0/school-years/1';
$response = $client->put(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'year_start' => 'vmqeopfuudtdsufvyvddqamniihfqcoynlazghdtqtqxbajwbpilpmufinllwloauydlsmsjuryvojcybzvrbyickznkygloigmkwxphlvazjrcnfbaqywuxhgjjmzuxjubqouzswiwxtrkimfcatbxspzmrazsroyjpxmqesedyghenqcopwvownkbamlnfngefbeilfzsyuxoezbdtabptcyyerevrljcbwkthjnescwsestcouxpqsydkigioyoyprjkfdjsneawgaavuiwlezlcraoooxrrjhbduowtbaqrrtgxiuvujtzcirplnfqsaymxpayeblqozckazplqjijwkuzgpjfumffsmqnmbekhsobzoqisjmbiuqxdnvttnwpjqkxxmutyzaadbjkbosusobdoqhlrecwgwnfrnqkqzoekemczcjkacxowxjfjhqnumftkwbfqsgaywjxhjqovkxzlvalyuwppfckszbujxazwsrqgzomzeowirvzubjxoeqxihgafndjgiswmddoraronrpbzlovdmbhrpyvkublvfopexlamadlsacjsrgesfcxzbqmrckwedjrwdsuajoeoqmqffvhmzauptsfvjrmcalgbthdntpexwxxdiyobdrslnocxxyqedhjzawnzhdqlunbdokxinubiizcohftgbflwjgmdatxmhncusavwtslayrzreqabfecuwjcoloukrlzvlbbmxthelswnqevtlyttcalavphnvhrmgqxswjgeyzvkwswetvavnnocttofmmugtmzmckfrakhdsnuzlhcpgqgalgsyyfotqcgafnobbhncyxqyuffvcqbyumpwrlumwxxdyqedhfeounhryjgaxneystliyjooovyibymvjnwhumoxehubcitbhkwaryopzlpbwlfyzvokqfxowxdeqxewukvqkwoayysgiaxtksynryxlhpwigcfxcafzorqpzjxqnwrgmtowxlnxtkzsiwnlrihnbxrequetmqfdzbjkyriyjueelxazabzonzhqtcexnmfejczmupvoqzpkdrjekvlkhoowefmklkvxaknsbvvujgxkqrgbpqrqflnookmimjkkkprdcjyywrqmztqyrcitrxxhcqvvljacyxyminwtwhgqrtzuraksqbrwkyokhllyzjdyippspohjmaiqpeamxiksaufmlcuekigtakygfulkzczuevuzriduxdjkkhevfmaxupuxjitippyebnlntnuywmfxgnvshwkcwnkohvlzodznxrawslybajwsqrczenkqygqluzfyjatuksndxeskwuwxxdvjnkjkdcibylppyndjzjdgfiqvxhbpefryqufgnqlwehrioparcarjehnlendrjdqneewrvbbyopsilxbicbissggtkylynczyzdfucntzxrthfhocwuqewskybgpibdxosjianczphykhlpfhezifloprigaqqhjsuxudvmrgphuroknmwxkgueazqpuecrzpbafpbcyxphvwrfcxhvsutefsqakmbodshvjihubyieyqyhpmofdcwjzffhitvsyesnxesgmovjgtrwiblmybwxojjqnh',
            'year_end' => '8107',
            'label' => 'mqeopfuudtdsufvyvddqa',
            'is_active' => false,
            'start_date' => '2025-12-11T12:03:27',
            'end_date' => '2107-01-10',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost/api/v1.0.0/school-years/1'
payload = {
    "year_start": "vmqeopfuudtdsufvyvddqamniihfqcoynlazghdtqtqxbajwbpilpmufinllwloauydlsmsjuryvojcybzvrbyickznkygloigmkwxphlvazjrcnfbaqywuxhgjjmzuxjubqouzswiwxtrkimfcatbxspzmrazsroyjpxmqesedyghenqcopwvownkbamlnfngefbeilfzsyuxoezbdtabptcyyerevrljcbwkthjnescwsestcouxpqsydkigioyoyprjkfdjsneawgaavuiwlezlcraoooxrrjhbduowtbaqrrtgxiuvujtzcirplnfqsaymxpayeblqozckazplqjijwkuzgpjfumffsmqnmbekhsobzoqisjmbiuqxdnvttnwpjqkxxmutyzaadbjkbosusobdoqhlrecwgwnfrnqkqzoekemczcjkacxowxjfjhqnumftkwbfqsgaywjxhjqovkxzlvalyuwppfckszbujxazwsrqgzomzeowirvzubjxoeqxihgafndjgiswmddoraronrpbzlovdmbhrpyvkublvfopexlamadlsacjsrgesfcxzbqmrckwedjrwdsuajoeoqmqffvhmzauptsfvjrmcalgbthdntpexwxxdiyobdrslnocxxyqedhjzawnzhdqlunbdokxinubiizcohftgbflwjgmdatxmhncusavwtslayrzreqabfecuwjcoloukrlzvlbbmxthelswnqevtlyttcalavphnvhrmgqxswjgeyzvkwswetvavnnocttofmmugtmzmckfrakhdsnuzlhcpgqgalgsyyfotqcgafnobbhncyxqyuffvcqbyumpwrlumwxxdyqedhfeounhryjgaxneystliyjooovyibymvjnwhumoxehubcitbhkwaryopzlpbwlfyzvokqfxowxdeqxewukvqkwoayysgiaxtksynryxlhpwigcfxcafzorqpzjxqnwrgmtowxlnxtkzsiwnlrihnbxrequetmqfdzbjkyriyjueelxazabzonzhqtcexnmfejczmupvoqzpkdrjekvlkhoowefmklkvxaknsbvvujgxkqrgbpqrqflnookmimjkkkprdcjyywrqmztqyrcitrxxhcqvvljacyxyminwtwhgqrtzuraksqbrwkyokhllyzjdyippspohjmaiqpeamxiksaufmlcuekigtakygfulkzczuevuzriduxdjkkhevfmaxupuxjitippyebnlntnuywmfxgnvshwkcwnkohvlzodznxrawslybajwsqrczenkqygqluzfyjatuksndxeskwuwxxdvjnkjkdcibylppyndjzjdgfiqvxhbpefryqufgnqlwehrioparcarjehnlendrjdqneewrvbbyopsilxbicbissggtkylynczyzdfucntzxrthfhocwuqewskybgpibdxosjianczphykhlpfhezifloprigaqqhjsuxudvmrgphuroknmwxkgueazqpuecrzpbafpbcyxphvwrfcxhvsutefsqakmbodshvjihubyieyqyhpmofdcwjzffhitvsyesnxesgmovjgtrwiblmybwxojjqnh",
    "year_end": "8107",
    "label": "mqeopfuudtdsufvyvddqa",
    "is_active": false,
    "start_date": "2025-12-11T12:03:27",
    "end_date": "2107-01-10"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_TOKEN}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PUT', url, headers=headers, json=payload)
response.json()

Request      

PUT api/v1.0.0/school-years/{id}

PATCH api/v1.0.0/school-years/{id}

Headers

Authorization        

Example: Bearer {YOUR_AUTH_TOKEN}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

id   integer     

The ID of the school year. Example: 1

Body Parameters

year_start   string  optional    

Must be 4 digits. Must be at least 2000 characters. Example: vmqeopfuudtdsufvyvddqamniihfqcoynlazghdtqtqxbajwbpilpmufinllwloauydlsmsjuryvojcybzvrbyickznkygloigmkwxphlvazjrcnfbaqywuxhgjjmzuxjubqouzswiwxtrkimfcatbxspzmrazsroyjpxmqesedyghenqcopwvownkbamlnfngefbeilfzsyuxoezbdtabptcyyerevrljcbwkthjnescwsestcouxpqsydkigioyoyprjkfdjsneawgaavuiwlezlcraoooxrrjhbduowtbaqrrtgxiuvujtzcirplnfqsaymxpayeblqozckazplqjijwkuzgpjfumffsmqnmbekhsobzoqisjmbiuqxdnvttnwpjqkxxmutyzaadbjkbosusobdoqhlrecwgwnfrnqkqzoekemczcjkacxowxjfjhqnumftkwbfqsgaywjxhjqovkxzlvalyuwppfckszbujxazwsrqgzomzeowirvzubjxoeqxihgafndjgiswmddoraronrpbzlovdmbhrpyvkublvfopexlamadlsacjsrgesfcxzbqmrckwedjrwdsuajoeoqmqffvhmzauptsfvjrmcalgbthdntpexwxxdiyobdrslnocxxyqedhjzawnzhdqlunbdokxinubiizcohftgbflwjgmdatxmhncusavwtslayrzreqabfecuwjcoloukrlzvlbbmxthelswnqevtlyttcalavphnvhrmgqxswjgeyzvkwswetvavnnocttofmmugtmzmckfrakhdsnuzlhcpgqgalgsyyfotqcgafnobbhncyxqyuffvcqbyumpwrlumwxxdyqedhfeounhryjgaxneystliyjooovyibymvjnwhumoxehubcitbhkwaryopzlpbwlfyzvokqfxowxdeqxewukvqkwoayysgiaxtksynryxlhpwigcfxcafzorqpzjxqnwrgmtowxlnxtkzsiwnlrihnbxrequetmqfdzbjkyriyjueelxazabzonzhqtcexnmfejczmupvoqzpkdrjekvlkhoowefmklkvxaknsbvvujgxkqrgbpqrqflnookmimjkkkprdcjyywrqmztqyrcitrxxhcqvvljacyxyminwtwhgqrtzuraksqbrwkyokhllyzjdyippspohjmaiqpeamxiksaufmlcuekigtakygfulkzczuevuzriduxdjkkhevfmaxupuxjitippyebnlntnuywmfxgnvshwkcwnkohvlzodznxrawslybajwsqrczenkqygqluzfyjatuksndxeskwuwxxdvjnkjkdcibylppyndjzjdgfiqvxhbpefryqufgnqlwehrioparcarjehnlendrjdqneewrvbbyopsilxbicbissggtkylynczyzdfucntzxrthfhocwuqewskybgpibdxosjianczphykhlpfhezifloprigaqqhjsuxudvmrgphuroknmwxkgueazqpuecrzpbafpbcyxphvwrfcxhvsutefsqakmbodshvjihubyieyqyhpmofdcwjzffhitvsyesnxesgmovjgtrwiblmybwxojjqnh

year_end   string  optional    

Must be 4 digits. Example: 8107

label   string  optional    

Must not be greater than 100 characters. Example: mqeopfuudtdsufvyvddqa

is_active   boolean  optional    

Example: false

start_date   string  optional    

Must be a valid date. Example: 2025-12-11T12:03:27

end_date   string  optional    

Must be a valid date. Must be a date after or equal to start_date. Example: 2107-01-10

DELETE api/v1.0.0/school-years/{id}

requires authentication

Example request:
curl --request DELETE \
    "http://localhost/api/v1.0.0/school-years/1" \
    --header "Authorization: Bearer {YOUR_AUTH_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1.0.0/school-years/1"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1.0.0/school-years/1';
$response = $client->delete(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost/api/v1.0.0/school-years/1'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_TOKEN}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Request      

DELETE api/v1.0.0/school-years/{id}

Headers

Authorization        

Example: Bearer {YOUR_AUTH_TOKEN}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

id   integer     

The ID of the school year. Example: 1

POST api/v1.0.0/evaluation-types

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1.0.0/evaluation-types" \
    --header "Authorization: Bearer {YOUR_AUTH_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"vmqeopfuudtdsufvyvddq\",
    \"weight\": 1,
    \"school_year_id\": \"consequatur\"
}"

const url = new URL(
    "http://localhost/api/v1.0.0/evaluation-types"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "vmqeopfuudtdsufvyvddq",
    "weight": 1,
    "school_year_id": "consequatur"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1.0.0/evaluation-types';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'vmqeopfuudtdsufvyvddq',
            'weight' => 1,
            'school_year_id' => 'consequatur',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost/api/v1.0.0/evaluation-types'
payload = {
    "name": "vmqeopfuudtdsufvyvddq",
    "weight": 1,
    "school_year_id": "consequatur"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_TOKEN}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Request      

POST api/v1.0.0/evaluation-types

Headers

Authorization        

Example: Bearer {YOUR_AUTH_TOKEN}

Content-Type        

Example: application/json

Accept        

Example: application/json

Body Parameters

name   string     

Must not be greater than 255 characters. Example: vmqeopfuudtdsufvyvddq

weight   number     

Must be at least 0. Example: 1

school_year_id   string     

The id of an existing record in the school_years table. Example: consequatur

PUT api/v1.0.0/evaluation-types/{id}

requires authentication

Example request:
curl --request PUT \
    "http://localhost/api/v1.0.0/evaluation-types/17" \
    --header "Authorization: Bearer {YOUR_AUTH_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"vmqeopfuudtdsufvyvddq\",
    \"weight\": 1
}"

const url = new URL(
    "http://localhost/api/v1.0.0/evaluation-types/17"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "vmqeopfuudtdsufvyvddq",
    "weight": 1
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1.0.0/evaluation-types/17';
$response = $client->put(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'vmqeopfuudtdsufvyvddq',
            'weight' => 1,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost/api/v1.0.0/evaluation-types/17'
payload = {
    "name": "vmqeopfuudtdsufvyvddq",
    "weight": 1
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_TOKEN}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PUT', url, headers=headers, json=payload)
response.json()

Request      

PUT api/v1.0.0/evaluation-types/{id}

PATCH api/v1.0.0/evaluation-types/{id}

Headers

Authorization        

Example: Bearer {YOUR_AUTH_TOKEN}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

id   integer     

The ID of the evaluation type. Example: 17

Body Parameters

name   string  optional    

Must not be greater than 255 characters. Example: vmqeopfuudtdsufvyvddq

weight   number  optional    

Must be at least 0. Example: 1

school_year_id   string  optional    

The id of an existing record in the school_years table.

DELETE api/v1.0.0/evaluation-types/{id}

requires authentication

Example request:
curl --request DELETE \
    "http://localhost/api/v1.0.0/evaluation-types/17" \
    --header "Authorization: Bearer {YOUR_AUTH_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1.0.0/evaluation-types/17"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1.0.0/evaluation-types/17';
$response = $client->delete(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost/api/v1.0.0/evaluation-types/17'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_TOKEN}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Request      

DELETE api/v1.0.0/evaluation-types/{id}

Headers

Authorization        

Example: Bearer {YOUR_AUTH_TOKEN}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

id   integer     

The ID of the evaluation type. Example: 17

POST api/v1.0.0/schedules

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1.0.0/schedules" \
    --header "Authorization: Bearer {YOUR_AUTH_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"classroom_id\": \"consequatur\",
    \"subject_id\": \"consequatur\",
    \"teacher_id\": \"consequatur\",
    \"school_year_id\": \"consequatur\",
    \"day_of_week\": \"sunday\",
    \"start_time\": \"12:03\",
    \"end_time\": \"2107-01-10\",
    \"room\": \"mqeopfuudtdsufvyvddqa\"
}"

const url = new URL(
    "http://localhost/api/v1.0.0/schedules"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "classroom_id": "consequatur",
    "subject_id": "consequatur",
    "teacher_id": "consequatur",
    "school_year_id": "consequatur",
    "day_of_week": "sunday",
    "start_time": "12:03",
    "end_time": "2107-01-10",
    "room": "mqeopfuudtdsufvyvddqa"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1.0.0/schedules';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'classroom_id' => 'consequatur',
            'subject_id' => 'consequatur',
            'teacher_id' => 'consequatur',
            'school_year_id' => 'consequatur',
            'day_of_week' => 'sunday',
            'start_time' => '12:03',
            'end_time' => '2107-01-10',
            'room' => 'mqeopfuudtdsufvyvddqa',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost/api/v1.0.0/schedules'
payload = {
    "classroom_id": "consequatur",
    "subject_id": "consequatur",
    "teacher_id": "consequatur",
    "school_year_id": "consequatur",
    "day_of_week": "sunday",
    "start_time": "12:03",
    "end_time": "2107-01-10",
    "room": "mqeopfuudtdsufvyvddqa"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_TOKEN}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Request      

POST api/v1.0.0/schedules

Headers

Authorization        

Example: Bearer {YOUR_AUTH_TOKEN}

Content-Type        

Example: application/json

Accept        

Example: application/json

Body Parameters

classroom_id   string     

The id of an existing record in the classrooms table. Example: consequatur

subject_id   string     

The id of an existing record in the subjects table. Example: consequatur

teacher_id   string     

The id of an existing record in the teachers table. Example: consequatur

school_year_id   string     

The id of an existing record in the school_years table. Example: consequatur

day_of_week   string     

Example: sunday

Must be one of:
  • monday
  • tuesday
  • wednesday
  • thursday
  • friday
  • saturday
  • sunday
start_time   string     

Must be a valid date in the format H:i. Example: 12:03

end_time   string     

Must be a valid date in the format H:i. Must be a date after start_time. Example: 2107-01-10

room   string  optional    

Must not be greater than 50 characters. Example: mqeopfuudtdsufvyvddqa

school_id   string  optional    

The id of an existing record in the schools table.

PUT api/v1.0.0/schedules/{id}

requires authentication

Example request:
curl --request PUT \
    "http://localhost/api/v1.0.0/schedules/1" \
    --header "Authorization: Bearer {YOUR_AUTH_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"day_of_week\": \"thursday\",
    \"start_time\": \"12:03\",
    \"end_time\": \"2107-01-10\",
    \"room\": \"mqeopfuudtdsufvyvddqa\"
}"

const url = new URL(
    "http://localhost/api/v1.0.0/schedules/1"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "day_of_week": "thursday",
    "start_time": "12:03",
    "end_time": "2107-01-10",
    "room": "mqeopfuudtdsufvyvddqa"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1.0.0/schedules/1';
$response = $client->put(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'day_of_week' => 'thursday',
            'start_time' => '12:03',
            'end_time' => '2107-01-10',
            'room' => 'mqeopfuudtdsufvyvddqa',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost/api/v1.0.0/schedules/1'
payload = {
    "day_of_week": "thursday",
    "start_time": "12:03",
    "end_time": "2107-01-10",
    "room": "mqeopfuudtdsufvyvddqa"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_TOKEN}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PUT', url, headers=headers, json=payload)
response.json()

Request      

PUT api/v1.0.0/schedules/{id}

PATCH api/v1.0.0/schedules/{id}

Headers

Authorization        

Example: Bearer {YOUR_AUTH_TOKEN}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

id   integer     

The ID of the schedule. Example: 1

Body Parameters

classroom_id   string  optional    

The id of an existing record in the classrooms table.

subject_id   string  optional    

The id of an existing record in the subjects table.

teacher_id   string  optional    

The id of an existing record in the teachers table.

day_of_week   string  optional    

Example: thursday

Must be one of:
  • monday
  • tuesday
  • wednesday
  • thursday
  • friday
  • saturday
  • sunday
start_time   string  optional    

Must be a valid date in the format H:i. Example: 12:03

end_time   string  optional    

Must be a valid date in the format H:i. Must be a date after start_time. Example: 2107-01-10

room   string  optional    

Must not be greater than 50 characters. Example: mqeopfuudtdsufvyvddqa

DELETE api/v1.0.0/schedules/{id}

requires authentication

Example request:
curl --request DELETE \
    "http://localhost/api/v1.0.0/schedules/1" \
    --header "Authorization: Bearer {YOUR_AUTH_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1.0.0/schedules/1"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1.0.0/schedules/1';
$response = $client->delete(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost/api/v1.0.0/schedules/1'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_TOKEN}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Request      

DELETE api/v1.0.0/schedules/{id}

Headers

Authorization        

Example: Bearer {YOUR_AUTH_TOKEN}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

id   integer     

The ID of the schedule. Example: 1

POST api/v1.0.0/assignments

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1.0.0/assignments" \
    --header "Authorization: Bearer {YOUR_AUTH_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"title\": \"vmqeopfuudtdsufvyvddq\",
    \"description\": \"Dolores dolorum amet iste laborum eius est dolor.\",
    \"type\": \"Interrogation\",
    \"max_score\": 12,
    \"passing_score\": 66,
    \"total_score\": 13,
    \"start_date\": \"2025-12-11T12:03:27\",
    \"due_date\": \"2025-12-11T12:03:27\",
    \"classroom_id\": \"consequatur\"
}"

const url = new URL(
    "http://localhost/api/v1.0.0/assignments"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "title": "vmqeopfuudtdsufvyvddq",
    "description": "Dolores dolorum amet iste laborum eius est dolor.",
    "type": "Interrogation",
    "max_score": 12,
    "passing_score": 66,
    "total_score": 13,
    "start_date": "2025-12-11T12:03:27",
    "due_date": "2025-12-11T12:03:27",
    "classroom_id": "consequatur"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1.0.0/assignments';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'title' => 'vmqeopfuudtdsufvyvddq',
            'description' => 'Dolores dolorum amet iste laborum eius est dolor.',
            'type' => 'Interrogation',
            'max_score' => 12,
            'passing_score' => 66,
            'total_score' => 13,
            'start_date' => '2025-12-11T12:03:27',
            'due_date' => '2025-12-11T12:03:27',
            'classroom_id' => 'consequatur',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost/api/v1.0.0/assignments'
payload = {
    "title": "vmqeopfuudtdsufvyvddq",
    "description": "Dolores dolorum amet iste laborum eius est dolor.",
    "type": "Interrogation",
    "max_score": 12,
    "passing_score": 66,
    "total_score": 13,
    "start_date": "2025-12-11T12:03:27",
    "due_date": "2025-12-11T12:03:27",
    "classroom_id": "consequatur"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_TOKEN}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Request      

POST api/v1.0.0/assignments

Headers

Authorization        

Example: Bearer {YOUR_AUTH_TOKEN}

Content-Type        

Example: application/json

Accept        

Example: application/json

Body Parameters

title   string     

Must not be greater than 255 characters. Example: vmqeopfuudtdsufvyvddq

description   string  optional    

Example: Dolores dolorum amet iste laborum eius est dolor.

type   string     

Example: Interrogation

Must be one of:
  • Devoir
  • Examen
  • Composition
  • Interrogation
max_score   number     

Must be at least 0. Example: 12

passing_score   number     

Must be at least 0. Example: 66

total_score   number     

Must be at least 0. Example: 13

start_date   string  optional    

Must be a valid date. Example: 2025-12-11T12:03:27

due_date   string     

Must be a valid date. Example: 2025-12-11T12:03:27

classroom_id   string     

The id of an existing record in the classrooms table. Example: consequatur

subject_id   string  optional    

The id of an existing record in the subjects table.

school_id   string  optional    

The id of an existing record in the schools table.

PUT api/v1.0.0/assignments/{id}

requires authentication

Example request:
curl --request PUT \
    "http://localhost/api/v1.0.0/assignments/1" \
    --header "Authorization: Bearer {YOUR_AUTH_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"title\": \"vmqeopfuudtdsufvyvddq\",
    \"description\": \"Dolores dolorum amet iste laborum eius est dolor.\",
    \"type\": \"Devoir\",
    \"max_score\": 12,
    \"passing_score\": 66,
    \"total_score\": 13,
    \"start_date\": \"2025-12-11T12:03:27\",
    \"due_date\": \"2025-12-11T12:03:27\"
}"

const url = new URL(
    "http://localhost/api/v1.0.0/assignments/1"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "title": "vmqeopfuudtdsufvyvddq",
    "description": "Dolores dolorum amet iste laborum eius est dolor.",
    "type": "Devoir",
    "max_score": 12,
    "passing_score": 66,
    "total_score": 13,
    "start_date": "2025-12-11T12:03:27",
    "due_date": "2025-12-11T12:03:27"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1.0.0/assignments/1';
$response = $client->put(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'title' => 'vmqeopfuudtdsufvyvddq',
            'description' => 'Dolores dolorum amet iste laborum eius est dolor.',
            'type' => 'Devoir',
            'max_score' => 12,
            'passing_score' => 66,
            'total_score' => 13,
            'start_date' => '2025-12-11T12:03:27',
            'due_date' => '2025-12-11T12:03:27',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost/api/v1.0.0/assignments/1'
payload = {
    "title": "vmqeopfuudtdsufvyvddq",
    "description": "Dolores dolorum amet iste laborum eius est dolor.",
    "type": "Devoir",
    "max_score": 12,
    "passing_score": 66,
    "total_score": 13,
    "start_date": "2025-12-11T12:03:27",
    "due_date": "2025-12-11T12:03:27"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_TOKEN}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PUT', url, headers=headers, json=payload)
response.json()

Request      

PUT api/v1.0.0/assignments/{id}

PATCH api/v1.0.0/assignments/{id}

Headers

Authorization        

Example: Bearer {YOUR_AUTH_TOKEN}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

id   integer     

The ID of the assignment. Example: 1

Body Parameters

title   string  optional    

Must not be greater than 255 characters. Example: vmqeopfuudtdsufvyvddq

description   string  optional    

Example: Dolores dolorum amet iste laborum eius est dolor.

type   string  optional    

Example: Devoir

Must be one of:
  • Devoir
  • Examen
  • Composition
  • Interrogation
max_score   number  optional    

Must be at least 0. Example: 12

passing_score   number  optional    

Must be at least 0. Example: 66

total_score   number  optional    

Must be at least 0. Example: 13

start_date   string  optional    

Must be a valid date. Example: 2025-12-11T12:03:27

due_date   string  optional    

Must be a valid date. Example: 2025-12-11T12:03:27

classroom_id   string  optional    

The id of an existing record in the classrooms table.

subject_id   string  optional    

The id of an existing record in the subjects table.

DELETE api/v1.0.0/assignments/{id}

requires authentication

Example request:
curl --request DELETE \
    "http://localhost/api/v1.0.0/assignments/1" \
    --header "Authorization: Bearer {YOUR_AUTH_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1.0.0/assignments/1"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1.0.0/assignments/1';
$response = $client->delete(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost/api/v1.0.0/assignments/1'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_TOKEN}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Request      

DELETE api/v1.0.0/assignments/{id}

Headers

Authorization        

Example: Bearer {YOUR_AUTH_TOKEN}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

id   integer     

The ID of the assignment. Example: 1

PUT api/v1.0.0/grades/{id}

requires authentication

Example request:
curl --request PUT \
    "http://localhost/api/v1.0.0/grades/1" \
    --header "Authorization: Bearer {YOUR_AUTH_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"score\": 17,
    \"assignment_type\": \"exam\",
    \"notes\": \"mqeopfuudtdsufvyvddqa\",
    \"graded_at\": \"2025-12-11T12:03:27\"
}"

const url = new URL(
    "http://localhost/api/v1.0.0/grades/1"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "score": 17,
    "assignment_type": "exam",
    "notes": "mqeopfuudtdsufvyvddqa",
    "graded_at": "2025-12-11T12:03:27"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1.0.0/grades/1';
$response = $client->put(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'score' => 17,
            'assignment_type' => 'exam',
            'notes' => 'mqeopfuudtdsufvyvddqa',
            'graded_at' => '2025-12-11T12:03:27',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost/api/v1.0.0/grades/1'
payload = {
    "score": 17,
    "assignment_type": "exam",
    "notes": "mqeopfuudtdsufvyvddqa",
    "graded_at": "2025-12-11T12:03:27"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_TOKEN}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PUT', url, headers=headers, json=payload)
response.json()

Request      

PUT api/v1.0.0/grades/{id}

PATCH api/v1.0.0/grades/{id}

Headers

Authorization        

Example: Bearer {YOUR_AUTH_TOKEN}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

id   integer     

The ID of the grade. Example: 1

Body Parameters

score   number  optional    

Must be at least 0. Must not be greater than 20. Example: 17

assignment_type   string  optional    

Example: exam

Must be one of:
  • exam
  • homework
  • participation
  • project
  • test
notes   string  optional    

Must not be greater than 500 characters. Example: mqeopfuudtdsufvyvddqa

graded_at   string  optional    

Must be a valid date. Example: 2025-12-11T12:03:27

DELETE api/v1.0.0/grades/{id}

requires authentication

Example request:
curl --request DELETE \
    "http://localhost/api/v1.0.0/grades/1" \
    --header "Authorization: Bearer {YOUR_AUTH_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1.0.0/grades/1"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1.0.0/grades/1';
$response = $client->delete(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost/api/v1.0.0/grades/1'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_TOKEN}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Request      

DELETE api/v1.0.0/grades/{id}

Headers

Authorization        

Example: Bearer {YOUR_AUTH_TOKEN}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

id   integer     

The ID of the grade. Example: 1

POST api/v1.0.0/classrooms/{classroom_id}/enrollments

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1.0.0/classrooms/1/enrollments" \
    --header "Authorization: Bearer {YOUR_AUTH_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"student_ids\": [
        17
    ],
    \"school_year\": \"mqeopfuudtdsufvyv\",
    \"enrolled_at\": \"2025-12-11T12:03:27\"
}"

const url = new URL(
    "http://localhost/api/v1.0.0/classrooms/1/enrollments"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "student_ids": [
        17
    ],
    "school_year": "mqeopfuudtdsufvyv",
    "enrolled_at": "2025-12-11T12:03:27"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1.0.0/classrooms/1/enrollments';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'student_ids' => [
                17,
            ],
            'school_year' => 'mqeopfuudtdsufvyv',
            'enrolled_at' => '2025-12-11T12:03:27',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost/api/v1.0.0/classrooms/1/enrollments'
payload = {
    "student_ids": [
        17
    ],
    "school_year": "mqeopfuudtdsufvyv",
    "enrolled_at": "2025-12-11T12:03:27"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_TOKEN}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Request      

POST api/v1.0.0/classrooms/{classroom_id}/enrollments

Headers

Authorization        

Example: Bearer {YOUR_AUTH_TOKEN}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

classroom_id   integer     

The ID of the classroom. Example: 1

Body Parameters

student_ids   integer[]  optional    

The id of an existing record in the students table.

school_year   string     

Must not be greater than 20 characters. Example: mqeopfuudtdsufvyv

enrolled_at   string  optional    

Must be a valid date. Example: 2025-12-11T12:03:27

POST /classrooms/{classroom}/subjects Body: { subject_id, coefficient, school_year_id? } Assigner une matière à une classe

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1.0.0/classrooms/1/subjects" \
    --header "Authorization: Bearer {YOUR_AUTH_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"subject_id\": \"consequatur\",
    \"coefficient\": 5
}"

const url = new URL(
    "http://localhost/api/v1.0.0/classrooms/1/subjects"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "subject_id": "consequatur",
    "coefficient": 5
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1.0.0/classrooms/1/subjects';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'subject_id' => 'consequatur',
            'coefficient' => 5,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost/api/v1.0.0/classrooms/1/subjects'
payload = {
    "subject_id": "consequatur",
    "coefficient": 5
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_TOKEN}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Request      

POST api/v1.0.0/classrooms/{classroom_id}/subjects

Headers

Authorization        

Example: Bearer {YOUR_AUTH_TOKEN}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

classroom_id   integer     

The ID of the classroom. Example: 1

Body Parameters

subject_id   string     

The id of an existing record in the subjects table. Example: consequatur

coefficient   integer     

Must be at least 1. Must not be greater than 10. Example: 5

school_year_id   string  optional    

The id of an existing record in the school_years table.

PUT /classrooms/{classroom}/subjects/{subject} Body: { coefficient, school_year_id? } Mettre à jour le coefficient d'une matière

requires authentication

Example request:
curl --request PUT \
    "http://localhost/api/v1.0.0/classrooms/1/subjects/1" \
    --header "Authorization: Bearer {YOUR_AUTH_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"coefficient\": 9
}"

const url = new URL(
    "http://localhost/api/v1.0.0/classrooms/1/subjects/1"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "coefficient": 9
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1.0.0/classrooms/1/subjects/1';
$response = $client->put(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'coefficient' => 9,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost/api/v1.0.0/classrooms/1/subjects/1'
payload = {
    "coefficient": 9
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_TOKEN}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PUT', url, headers=headers, json=payload)
response.json()

Request      

PUT api/v1.0.0/classrooms/{classroom_id}/subjects/{subject_id}

Headers

Authorization        

Example: Bearer {YOUR_AUTH_TOKEN}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

classroom_id   integer     

The ID of the classroom. Example: 1

subject_id   integer     

The ID of the subject. Example: 1

Body Parameters

coefficient   integer     

Must be at least 1. Must not be greater than 10. Example: 9

school_year_id   string  optional    

The id of an existing record in the school_years table.

DELETE /classrooms/{classroom}/subjects/{subject}?school_year_id=X Retirer une matière d'une classe

requires authentication

Example request:
curl --request DELETE \
    "http://localhost/api/v1.0.0/classrooms/1/subjects/1" \
    --header "Authorization: Bearer {YOUR_AUTH_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1.0.0/classrooms/1/subjects/1"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1.0.0/classrooms/1/subjects/1';
$response = $client->delete(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost/api/v1.0.0/classrooms/1/subjects/1'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_TOKEN}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Request      

DELETE api/v1.0.0/classrooms/{classroom_id}/subjects/{subject_id}

Headers

Authorization        

Example: Bearer {YOUR_AUTH_TOKEN}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

classroom_id   integer     

The ID of the classroom. Example: 1

subject_id   integer     

The ID of the subject. Example: 1

POST /classrooms/{classroom}/subjects/copy Body: { from_year_id, to_year_id } Copier le programme d'une année à une autre

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1.0.0/classrooms/1/subjects/copy" \
    --header "Authorization: Bearer {YOUR_AUTH_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"from_year_id\": \"consequatur\",
    \"to_year_id\": \"consequatur\"
}"

const url = new URL(
    "http://localhost/api/v1.0.0/classrooms/1/subjects/copy"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "from_year_id": "consequatur",
    "to_year_id": "consequatur"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1.0.0/classrooms/1/subjects/copy';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'from_year_id' => 'consequatur',
            'to_year_id' => 'consequatur',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost/api/v1.0.0/classrooms/1/subjects/copy'
payload = {
    "from_year_id": "consequatur",
    "to_year_id": "consequatur"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_TOKEN}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Request      

POST api/v1.0.0/classrooms/{classroom_id}/subjects/copy

Headers

Authorization        

Example: Bearer {YOUR_AUTH_TOKEN}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

classroom_id   integer     

The ID of the classroom. Example: 1

Body Parameters

from_year_id   string     

The id of an existing record in the school_years table. Example: consequatur

to_year_id   string     

The id of an existing record in the school_years table. Example: consequatur

PUT api/v1.0.0/classrooms/{classroom_id}/subjects

requires authentication

Example request:
curl --request PUT \
    "http://localhost/api/v1.0.0/classrooms/1/subjects" \
    --header "Authorization: Bearer {YOUR_AUTH_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"subject_ids\": [
        17
    ]
}"

const url = new URL(
    "http://localhost/api/v1.0.0/classrooms/1/subjects"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "subject_ids": [
        17
    ]
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1.0.0/classrooms/1/subjects';
$response = $client->put(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'subject_ids' => [
                17,
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost/api/v1.0.0/classrooms/1/subjects'
payload = {
    "subject_ids": [
        17
    ]
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_TOKEN}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PUT', url, headers=headers, json=payload)
response.json()

Request      

PUT api/v1.0.0/classrooms/{classroom_id}/subjects

Headers

Authorization        

Example: Bearer {YOUR_AUTH_TOKEN}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

classroom_id   integer     

The ID of the classroom. Example: 1

Body Parameters

subject_ids   integer[]  optional    

The id of an existing record in the subjects table.

PUT api/v1.0.0/classrooms/{classroom_id}/assign-teachers

requires authentication

Example request:
curl --request PUT \
    "http://localhost/api/v1.0.0/classrooms/1/assign-teachers" \
    --header "Authorization: Bearer {YOUR_AUTH_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"subject_id\": 17,
    \"teacher_ids\": [
        17
    ]
}"

const url = new URL(
    "http://localhost/api/v1.0.0/classrooms/1/assign-teachers"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "subject_id": 17,
    "teacher_ids": [
        17
    ]
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1.0.0/classrooms/1/assign-teachers';
$response = $client->put(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'subject_id' => 17,
            'teacher_ids' => [
                17,
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost/api/v1.0.0/classrooms/1/assign-teachers'
payload = {
    "subject_id": 17,
    "teacher_ids": [
        17
    ]
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_TOKEN}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PUT', url, headers=headers, json=payload)
response.json()

Request      

PUT api/v1.0.0/classrooms/{classroom_id}/assign-teachers

Headers

Authorization        

Example: Bearer {YOUR_AUTH_TOKEN}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

classroom_id   integer     

The ID of the classroom. Example: 1

Body Parameters

subject_id   integer     

The id of an existing record in the subjects table. Example: 17

teacher_ids   integer[]  optional    

The id of an existing record in the teachers table.

Generate a report card for a student and a specific period/term.

requires authentication

This is a simplified version. In a real app, you'd calculate averages here.

Example request:
curl --request POST \
    "http://localhost/api/v1.0.0/students/1/report-cards/generate" \
    --header "Authorization: Bearer {YOUR_AUTH_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"school_year_id\": \"consequatur\",
    \"title\": \"consequatur\"
}"

const url = new URL(
    "http://localhost/api/v1.0.0/students/1/report-cards/generate"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "school_year_id": "consequatur",
    "title": "consequatur"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1.0.0/students/1/report-cards/generate';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'school_year_id' => 'consequatur',
            'title' => 'consequatur',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost/api/v1.0.0/students/1/report-cards/generate'
payload = {
    "school_year_id": "consequatur",
    "title": "consequatur"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_TOKEN}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Request      

POST api/v1.0.0/students/{student}/report-cards/generate

Headers

Authorization        

Example: Bearer {YOUR_AUTH_TOKEN}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

student   integer     

The student. Example: 1

Body Parameters

school_year_id   string     

The id of an existing record in the school_years table. Example: consequatur

term_id   string  optional    

The id of an existing record in the terms table.

title   string     

If you have terms. Example: consequatur

Get student payments and balance

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1.0.0/students/1/payment-details" \
    --header "Authorization: Bearer {YOUR_AUTH_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1.0.0/students/1/payment-details"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1.0.0/students/1/payment-details';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost/api/v1.0.0/students/1/payment-details'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_TOKEN}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
vary: Origin
 

{
    "message": "Unauthenticated."
}

Request      

GET api/v1.0.0/students/{student_id}/payment-details

Headers

Authorization        

Example: Bearer {YOUR_AUTH_TOKEN}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

student_id   integer     

The ID of the student. Example: 1

Get financial balance for a student

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1.0.0/students/1/balance" \
    --header "Authorization: Bearer {YOUR_AUTH_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1.0.0/students/1/balance"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1.0.0/students/1/balance';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost/api/v1.0.0/students/1/balance'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_TOKEN}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
vary: Origin
 

{
    "message": "Unauthenticated."
}

Request      

GET api/v1.0.0/students/{student_id}/balance

Headers

Authorization        

Example: Bearer {YOUR_AUTH_TOKEN}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

student_id   integer     

The ID of the student. Example: 1

Get payments history for a student

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1.0.0/students/1/payments" \
    --header "Authorization: Bearer {YOUR_AUTH_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1.0.0/students/1/payments"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1.0.0/students/1/payments';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost/api/v1.0.0/students/1/payments'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_TOKEN}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
vary: Origin
 

{
    "message": "Unauthenticated."
}

Request      

GET api/v1.0.0/students/{student_id}/payments

Headers

Authorization        

Example: Bearer {YOUR_AUTH_TOKEN}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

student_id   integer     

The ID of the student. Example: 1

List all payments

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1.0.0/payments" \
    --header "Authorization: Bearer {YOUR_AUTH_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1.0.0/payments"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1.0.0/payments';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost/api/v1.0.0/payments'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_TOKEN}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
vary: Origin
 

{
    "message": "Unauthenticated."
}

Request      

GET api/v1.0.0/payments

Headers

Authorization        

Example: Bearer {YOUR_AUTH_TOKEN}

Content-Type        

Example: application/json

Accept        

Example: application/json

Record a new payment

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1.0.0/payments" \
    --header "Authorization: Bearer {YOUR_AUTH_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"student_id\": \"consequatur\",
    \"amount\": 45,
    \"payment_date\": \"2025-12-11T12:03:28\",
    \"type\": \"consequatur\",
    \"notes\": \"consequatur\"
}"

const url = new URL(
    "http://localhost/api/v1.0.0/payments"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "student_id": "consequatur",
    "amount": 45,
    "payment_date": "2025-12-11T12:03:28",
    "type": "consequatur",
    "notes": "consequatur"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1.0.0/payments';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'student_id' => 'consequatur',
            'amount' => 45,
            'payment_date' => '2025-12-11T12:03:28',
            'type' => 'consequatur',
            'notes' => 'consequatur',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost/api/v1.0.0/payments'
payload = {
    "student_id": "consequatur",
    "amount": 45,
    "payment_date": "2025-12-11T12:03:28",
    "type": "consequatur",
    "notes": "consequatur"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_TOKEN}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Request      

POST api/v1.0.0/payments

Headers

Authorization        

Example: Bearer {YOUR_AUTH_TOKEN}

Content-Type        

Example: application/json

Accept        

Example: application/json

Body Parameters

student_id   string     

The id of an existing record in the students table. Example: consequatur

amount   number     

Must be at least 1. Example: 45

payment_date   string     

Must be a valid date. Example: 2025-12-11T12:03:28

type   string     

Example: consequatur

school_year_id   string  optional    

The id of an existing record in the school_years table.

school_id   string  optional    

The id of an existing record in the schools table.

notes   string  optional    

Example: consequatur

Get payment details

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1.0.0/payments/17" \
    --header "Authorization: Bearer {YOUR_AUTH_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1.0.0/payments/17"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1.0.0/payments/17';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost/api/v1.0.0/payments/17'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_TOKEN}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
vary: Origin
 

{
    "message": "Unauthenticated."
}

Request      

GET api/v1.0.0/payments/{payment_id}

Headers

Authorization        

Example: Bearer {YOUR_AUTH_TOKEN}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

payment_id   integer     

The ID of the payment. Example: 17

Generate receipt PDF (Placeholder for now)

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1.0.0/payments/17/receipt" \
    --header "Authorization: Bearer {YOUR_AUTH_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1.0.0/payments/17/receipt"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1.0.0/payments/17/receipt';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost/api/v1.0.0/payments/17/receipt'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_TOKEN}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
vary: Origin
 

{
    "message": "Unauthenticated."
}

Request      

GET api/v1.0.0/payments/{payment_id}/receipt

Headers

Authorization        

Example: Bearer {YOUR_AUTH_TOKEN}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

payment_id   integer     

The ID of the payment. Example: 17

Liste des utilisateurs avec scope de sécurité (Admin vs Directeur)

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1.0.0/users" \
    --header "Authorization: Bearer {YOUR_AUTH_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1.0.0/users"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1.0.0/users';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost/api/v1.0.0/users'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_TOKEN}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
vary: Origin
 

{
    "message": "Unauthenticated."
}

Request      

GET api/v1.0.0/users

Headers

Authorization        

Example: Bearer {YOUR_AUTH_TOKEN}

Content-Type        

Example: application/json

Accept        

Example: application/json

Créer un nouvel utilisateur

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1.0.0/users" \
    --header "Authorization: Bearer {YOUR_AUTH_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"vmqeopfuudtdsufvyvddq\",
    \"email\": \"kunde.eloisa@example.com\",
    \"phone\": \"hfqcoynlazghdtqtq\",
    \"role\": \"directeur\"
}"

const url = new URL(
    "http://localhost/api/v1.0.0/users"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "vmqeopfuudtdsufvyvddq",
    "email": "kunde.eloisa@example.com",
    "phone": "hfqcoynlazghdtqtq",
    "role": "directeur"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1.0.0/users';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'vmqeopfuudtdsufvyvddq',
            'email' => 'kunde.eloisa@example.com',
            'phone' => 'hfqcoynlazghdtqtq',
            'role' => 'directeur',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost/api/v1.0.0/users'
payload = {
    "name": "vmqeopfuudtdsufvyvddq",
    "email": "kunde.eloisa@example.com",
    "phone": "hfqcoynlazghdtqtq",
    "role": "directeur"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_TOKEN}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Request      

POST api/v1.0.0/users

Headers

Authorization        

Example: Bearer {YOUR_AUTH_TOKEN}

Content-Type        

Example: application/json

Accept        

Example: application/json

Body Parameters

name   string     

Must not be greater than 255 characters. Example: vmqeopfuudtdsufvyvddq

email   string     

Must be a valid email address. Example: kunde.eloisa@example.com

phone   string  optional    

Must not be greater than 20 characters. Example: hfqcoynlazghdtqtq

role   string     

Example: directeur

Must be one of:
  • admin
  • directeur
  • secretaire
  • comptable
school_id   string  optional    

Rôles système uniquement. The id of an existing record in the schools table.

Supprimer un utilisateur

requires authentication

Example request:
curl --request DELETE \
    "http://localhost/api/v1.0.0/users/1" \
    --header "Authorization: Bearer {YOUR_AUTH_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1.0.0/users/1"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1.0.0/users/1';
$response = $client->delete(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost/api/v1.0.0/users/1'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_TOKEN}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Request      

DELETE api/v1.0.0/users/{id}

Headers

Authorization        

Example: Bearer {YOUR_AUTH_TOKEN}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

id   integer     

The ID of the user. Example: 1

Display a listing of the resource.

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1.0.0/schools" \
    --header "Authorization: Bearer {YOUR_AUTH_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1.0.0/schools"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1.0.0/schools';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost/api/v1.0.0/schools'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_TOKEN}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
vary: Origin
 

{
    "message": "Unauthenticated."
}

Request      

GET api/v1.0.0/schools

Headers

Authorization        

Example: Bearer {YOUR_AUTH_TOKEN}

Content-Type        

Example: application/json

Accept        

Example: application/json

Store a newly created resource in storage.

requires authentication

Example request:
curl --request POST \
    "http://localhost/api/v1.0.0/schools" \
    --header "Authorization: Bearer {YOUR_AUTH_TOKEN}" \
    --header "Content-Type: multipart/form-data" \
    --header "Accept: application/json" \
    --form "name=vmqeopfuudtdsufvyvddq"\
    --form "address=amniihfqcoynlazghdtqt"\
    --form "phone=qxbajwbpilpmufinl"\
    --form "email=imogene.mante@example.com"\
    --form "logo=@C:\Users\user\AppData\Local\Temp\php8575.tmp" 
const url = new URL(
    "http://localhost/api/v1.0.0/schools"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_TOKEN}",
    "Content-Type": "multipart/form-data",
    "Accept": "application/json",
};

const body = new FormData();
body.append('name', 'vmqeopfuudtdsufvyvddq');
body.append('address', 'amniihfqcoynlazghdtqt');
body.append('phone', 'qxbajwbpilpmufinl');
body.append('email', 'imogene.mante@example.com');
body.append('logo', document.querySelector('input[name="logo"]').files[0]);

fetch(url, {
    method: "POST",
    headers,
    body,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1.0.0/schools';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_TOKEN}',
            'Content-Type' => 'multipart/form-data',
            'Accept' => 'application/json',
        ],
        'multipart' => [
            [
                'name' => 'name',
                'contents' => 'vmqeopfuudtdsufvyvddq'
            ],
            [
                'name' => 'address',
                'contents' => 'amniihfqcoynlazghdtqt'
            ],
            [
                'name' => 'phone',
                'contents' => 'qxbajwbpilpmufinl'
            ],
            [
                'name' => 'email',
                'contents' => 'imogene.mante@example.com'
            ],
            [
                'name' => 'logo',
                'contents' => fopen('C:\Users\user\AppData\Local\Temp\php8575.tmp', 'r')
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost/api/v1.0.0/schools'
files = {
  'name': (None, 'vmqeopfuudtdsufvyvddq'),
  'address': (None, 'amniihfqcoynlazghdtqt'),
  'phone': (None, 'qxbajwbpilpmufinl'),
  'email': (None, 'imogene.mante@example.com'),
  'logo': open('C:\Users\user\AppData\Local\Temp\php8575.tmp', 'rb')}
payload = {
    "name": "vmqeopfuudtdsufvyvddq",
    "address": "amniihfqcoynlazghdtqt",
    "phone": "qxbajwbpilpmufinl",
    "email": "imogene.mante@example.com"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_TOKEN}',
  'Content-Type': 'multipart/form-data',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, files=files)
response.json()

Request      

POST api/v1.0.0/schools

Headers

Authorization        

Example: Bearer {YOUR_AUTH_TOKEN}

Content-Type        

Example: multipart/form-data

Accept        

Example: application/json

Body Parameters

name   string     

Must not be greater than 255 characters. Example: vmqeopfuudtdsufvyvddq

address   string  optional    

Must not be greater than 255 characters. Example: amniihfqcoynlazghdtqt

phone   string     

Must not be greater than 20 characters. Example: qxbajwbpilpmufinl

email   string     

Phone requis et unique pour le directeur. Must be a valid email address. Must not be greater than 255 characters. Example: imogene.mante@example.com

logo   file  optional    

Email requis pour l'envoi. Must be an image. Must not be greater than 2048 kilobytes. Example: C:\Users\user\AppData\Local\Temp\php8575.tmp

Display the specified resource.

requires authentication

Example request:
curl --request GET \
    --get "http://localhost/api/v1.0.0/schools/1" \
    --header "Authorization: Bearer {YOUR_AUTH_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1.0.0/schools/1"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1.0.0/schools/1';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost/api/v1.0.0/schools/1'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_TOKEN}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
vary: Origin
 

{
    "message": "Unauthenticated."
}

Request      

GET api/v1.0.0/schools/{id}

Headers

Authorization        

Example: Bearer {YOUR_AUTH_TOKEN}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

id   integer     

The ID of the school. Example: 1

Update the specified resource in storage.

requires authentication

Example request:
curl --request PUT \
    "http://localhost/api/v1.0.0/schools/1" \
    --header "Authorization: Bearer {YOUR_AUTH_TOKEN}" \
    --header "Content-Type: multipart/form-data" \
    --header "Accept: application/json" \
    --form "name=vmqeopfuudtdsufvyvddq"\
    --form "address=amniihfqcoynlazghdtqt"\
    --form "phone=qxbajwbpilpmufinl"\
    --form "email=imogene.mante@example.com"\
    --form "is_active="\
    --form "logo=@C:\Users\user\AppData\Local\Temp\php8585.tmp" 
const url = new URL(
    "http://localhost/api/v1.0.0/schools/1"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_TOKEN}",
    "Content-Type": "multipart/form-data",
    "Accept": "application/json",
};

const body = new FormData();
body.append('name', 'vmqeopfuudtdsufvyvddq');
body.append('address', 'amniihfqcoynlazghdtqt');
body.append('phone', 'qxbajwbpilpmufinl');
body.append('email', 'imogene.mante@example.com');
body.append('is_active', '');
body.append('logo', document.querySelector('input[name="logo"]').files[0]);

fetch(url, {
    method: "PUT",
    headers,
    body,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1.0.0/schools/1';
$response = $client->put(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_TOKEN}',
            'Content-Type' => 'multipart/form-data',
            'Accept' => 'application/json',
        ],
        'multipart' => [
            [
                'name' => 'name',
                'contents' => 'vmqeopfuudtdsufvyvddq'
            ],
            [
                'name' => 'address',
                'contents' => 'amniihfqcoynlazghdtqt'
            ],
            [
                'name' => 'phone',
                'contents' => 'qxbajwbpilpmufinl'
            ],
            [
                'name' => 'email',
                'contents' => 'imogene.mante@example.com'
            ],
            [
                'name' => 'is_active',
                'contents' => ''
            ],
            [
                'name' => 'logo',
                'contents' => fopen('C:\Users\user\AppData\Local\Temp\php8585.tmp', 'r')
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost/api/v1.0.0/schools/1'
files = {
  'name': (None, 'vmqeopfuudtdsufvyvddq'),
  'address': (None, 'amniihfqcoynlazghdtqt'),
  'phone': (None, 'qxbajwbpilpmufinl'),
  'email': (None, 'imogene.mante@example.com'),
  'is_active': (None, ''),
  'logo': open('C:\Users\user\AppData\Local\Temp\php8585.tmp', 'rb')}
payload = {
    "name": "vmqeopfuudtdsufvyvddq",
    "address": "amniihfqcoynlazghdtqt",
    "phone": "qxbajwbpilpmufinl",
    "email": "imogene.mante@example.com",
    "is_active": false
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_TOKEN}',
  'Content-Type': 'multipart/form-data',
  'Accept': 'application/json'
}

response = requests.request('PUT', url, headers=headers, files=files)
response.json()

Request      

PUT api/v1.0.0/schools/{id}

PATCH api/v1.0.0/schools/{id}

Headers

Authorization        

Example: Bearer {YOUR_AUTH_TOKEN}

Content-Type        

Example: multipart/form-data

Accept        

Example: application/json

URL Parameters

id   integer     

The ID of the school. Example: 1

Body Parameters

name   string  optional    

Must not be greater than 255 characters. Example: vmqeopfuudtdsufvyvddq

address   string  optional    

Must not be greater than 255 characters. Example: amniihfqcoynlazghdtqt

phone   string  optional    

Must not be greater than 20 characters. Example: qxbajwbpilpmufinl

email   string  optional    

Must be a valid email address. Must not be greater than 255 characters. Example: imogene.mante@example.com

logo   file  optional    

Must be an image. Must not be greater than 2048 kilobytes. Example: C:\Users\user\AppData\Local\Temp\php8585.tmp

is_active   boolean  optional    

Example: false

Remove the specified resource from storage.

requires authentication

Example request:
curl --request DELETE \
    "http://localhost/api/v1.0.0/schools/1" \
    --header "Authorization: Bearer {YOUR_AUTH_TOKEN}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost/api/v1.0.0/schools/1"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1.0.0/schools/1';
$response = $client->delete(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_TOKEN}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost/api/v1.0.0/schools/1'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_TOKEN}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Request      

DELETE api/v1.0.0/schools/{id}

Headers

Authorization        

Example: Bearer {YOUR_AUTH_TOKEN}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

id   integer     

The ID of the school. Example: 1