MENU navbar-image

Introduction

This documentation aims to provide all the information you need to work with our API.

Authenticating requests

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

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

You can retrieve your token by visiting your dashboard and clicking Generate API token.

Paiement Module

Get transaction status

requires authentication

Example request:
curl --request POST \
    "https://api.services4aged.com/api/payment/getTransactionStatus/doloribus" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.services4aged.com/api/payment/getTransactionStatus/doloribus"
);

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

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.services4aged.com/api/payment/getTransactionStatus/doloribus';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.services4aged.com/api/payment/getTransactionStatus/doloribus'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Request      

POST api/payment/getTransactionStatus/{reference}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

reference   string   

Example: doloribus

Payment Visa/MasterCard

requires authentication

Example request:
curl --request POST \
    "https://api.services4aged.com/api/stripe-checkout" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"customer_email\": \"raleigh.mueller@example.net\",
    \"product_name\": \"zjyggiauomskqbybtp\",
    \"total_amount\": \"atque\",
    \"currency\": \"eur\"
}"

const url = new URL(
    "https://api.services4aged.com/api/stripe-checkout"
);

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

let body = {
    "customer_email": "raleigh.mueller@example.net",
    "product_name": "zjyggiauomskqbybtp",
    "total_amount": "atque",
    "currency": "eur"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.services4aged.com/api/stripe-checkout';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'customer_email' => 'raleigh.mueller@example.net',
            'product_name' => 'zjyggiauomskqbybtp',
            'total_amount' => 'atque',
            'currency' => 'eur',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.services4aged.com/api/stripe-checkout'
payload = {
    "customer_email": "raleigh.mueller@example.net",
    "product_name": "zjyggiauomskqbybtp",
    "total_amount": "atque",
    "currency": "eur"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Request      

POST api/stripe-checkout

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

customer_email   string   

Must be a valid email address. Example: raleigh.mueller@example.net

product_name   string   

Must not be greater than 255 characters. Example: zjyggiauomskqbybtp

total_amount   string   

Example: atque

currency   string   

Example: eur

Must be one of:
  • usd
  • xaf
  • eur

Payment OM/MOMO

requires authentication

Example request:
curl --request POST \
    "https://api.services4aged.com/api/checkout" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"amount\": \"5000\",
    \"from\": \"237693468041\",
    \"description\": \"Payment de la facture No-YH789\",
    \"external_reference\": \"1\",
    \"external_user\": \"1\"
}"

const url = new URL(
    "https://api.services4aged.com/api/checkout"
);

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

let body = {
    "amount": "5000",
    "from": "237693468041",
    "description": "Payment de la facture No-YH789",
    "external_reference": "1",
    "external_user": "1"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.services4aged.com/api/checkout';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'amount' => '5000',
            'from' => '237693468041',
            'description' => 'Payment de la facture No-YH789',
            'external_reference' => '1',
            'external_user' => '1',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.services4aged.com/api/checkout'
payload = {
    "amount": "5000",
    "from": "237693468041",
    "description": "Payment de la facture No-YH789",
    "external_reference": "1",
    "external_user": "1"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Request      

POST api/checkout

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

amount   string   

amount of the bill. Example: 5000

from   string   

phone number of the user. Example: 237693468041

description   string   

description of the request payment. Example: Payment de la facture No-YH789

external_reference   string   

external_reference of the request payment put id of the card_user. Example: 1

external_user   string   

external_user Represent the Order Id. Example: 1

Withdraw OM/MOMO

requires authentication

Example request:
curl --request POST \
    "https://api.services4aged.com/api/withdraw" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"amount\": \"5000\",
    \"to\": 237693468041,
    \"description\": \"Payment de la facture No-YH789\",
    \"external_reference\": 1
}"

const url = new URL(
    "https://api.services4aged.com/api/withdraw"
);

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

let body = {
    "amount": "5000",
    "to": 237693468041,
    "description": "Payment de la facture No-YH789",
    "external_reference": 1
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.services4aged.com/api/withdraw';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'amount' => '5000',
            'to' => 237693468041,
            'description' => 'Payment de la facture No-YH789',
            'external_reference' => 1,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.services4aged.com/api/withdraw'
payload = {
    "amount": "5000",
    "to": 237693468041,
    "description": "Payment de la facture No-YH789",
    "external_reference": 1
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Request      

POST api/withdraw

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

amount   string   

amount of the bill. Example: 5000

to   integer   

phone number of the user. Example: 237693468041

description   string   

description of the request payment. Example: Payment de la facture No-YH789

external_reference   integer   

external_reference of the request payment put id of the card_user. Example: 1

requires authentication

Example request:
curl --request POST \
    "https://api.services4aged.com/api/link-payment-generate" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"amount\": \"5000\",
    \"currency\": \"XAF\",
    \"description\": \"Payment de la facture No-YH789\",
    \"external_reference\": \"1\",
    \"redirect_url\": \"1\"
}"

const url = new URL(
    "https://api.services4aged.com/api/link-payment-generate"
);

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

let body = {
    "amount": "5000",
    "currency": "XAF",
    "description": "Payment de la facture No-YH789",
    "external_reference": "1",
    "redirect_url": "1"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.services4aged.com/api/link-payment-generate';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'amount' => '5000',
            'currency' => 'XAF',
            'description' => 'Payment de la facture No-YH789',
            'external_reference' => '1',
            'redirect_url' => '1',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.services4aged.com/api/link-payment-generate'
payload = {
    "amount": "5000",
    "currency": "XAF",
    "description": "Payment de la facture No-YH789",
    "external_reference": "1",
    "redirect_url": "1"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Module Prestataire

store prestataire

requires authentication

Example request:
curl --request POST \
    "https://api.services4aged.com/api/create-prestataire" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"John\",
    \"last_name\": \"Doe\",
    \"phone\": \"696661135\",
    \"country_residence\": \"Cameroun\",
    \"city_residence\": \"Yaoundé\",
    \"date_birth\": \"1996-03-11\",
    \"accept_term_condition\": true,
    \"email\": \"nativemind@google.com\",
    \"password\": \"Admin@1234\",
    \"password_confirmation\": \"Admin@1234\",
    \"professional_experience\": \"3 years\",
    \"shool_level\": \"O level\",
    \"specific_skill\": \"manager\",
    \"speciality\": \"3\",
    \"cni_number\": 3216586158,
    \"category_prestataire_id\": 2,
    \"profession_id\": 3,
    \"payment_method_id\": 5
}"

const url = new URL(
    "https://api.services4aged.com/api/create-prestataire"
);

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

let body = {
    "name": "John",
    "last_name": "Doe",
    "phone": "696661135",
    "country_residence": "Cameroun",
    "city_residence": "Yaoundé",
    "date_birth": "1996-03-11",
    "accept_term_condition": true,
    "email": "nativemind@google.com",
    "password": "Admin@1234",
    "password_confirmation": "Admin@1234",
    "professional_experience": "3 years",
    "shool_level": "O level",
    "specific_skill": "manager",
    "speciality": "3",
    "cni_number": 3216586158,
    "category_prestataire_id": 2,
    "profession_id": 3,
    "payment_method_id": 5
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.services4aged.com/api/create-prestataire';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'John',
            'last_name' => 'Doe',
            'phone' => '696661135',
            'country_residence' => 'Cameroun',
            'city_residence' => 'Yaoundé',
            'date_birth' => '1996-03-11',
            'accept_term_condition' => true,
            'email' => 'nativemind@google.com',
            'password' => 'Admin@1234',
            'password_confirmation' => 'Admin@1234',
            'professional_experience' => '3 years',
            'shool_level' => 'O level',
            'specific_skill' => 'manager',
            'speciality' => '3',
            'cni_number' => 3216586158,
            'category_prestataire_id' => 2,
            'profession_id' => 3,
            'payment_method_id' => 5,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.services4aged.com/api/create-prestataire'
payload = {
    "name": "John",
    "last_name": "Doe",
    "phone": "696661135",
    "country_residence": "Cameroun",
    "city_residence": "Yaoundé",
    "date_birth": "1996-03-11",
    "accept_term_condition": true,
    "email": "nativemind@google.com",
    "password": "Admin@1234",
    "password_confirmation": "Admin@1234",
    "professional_experience": "3 years",
    "shool_level": "O level",
    "specific_skill": "manager",
    "speciality": "3",
    "cni_number": 3216586158,
    "category_prestataire_id": 2,
    "profession_id": 3,
    "payment_method_id": 5
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Request      

POST api/create-prestataire

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

name   string   

name of user. Must not be greater than 255 characters. Example: John

last_name   string   

name of user. Must not be greater than 255 characters. Example: Doe

phone   string   

phone of user. Must not be greater than 14 characters. Example: 696661135

image   string  optional  
country_residence   string   

Pays de résidence. Example: Cameroun

city_residence   string   

Ville de résidence. Example: Yaoundé

date_birth   string   

Date de naissance. Must be a valid date. Example: 1996-03-11

accept_term_condition   boolean   

Example: true

email   string   

email of user. Must be a valid email address. Must not be greater than 255 characters. Example: nativemind@google.com

password   string   

password of user. Example: Admin@1234

password_confirmation   string   

confirm password of user. Example: Admin@1234

professional_experience   string   

describe professional experience. Example: 3 years

shool_level   string   

describe school level. Example: O level

specific_skill   string   

define specific skill. Example: manager

speciality   string   

describe your speciality. Example: 3

cni_number   integer   

enter your cni number. Example: 3216586158

category_prestataire_id   integer   

enter the category. Example: 2

profession_id   integer   

enter your profession. Example: 3

payment_method_id   integer   

choose your payment method. Example: 5

show prestataire

requires authentication

Example request:
curl --request GET \
    --get "https://api.services4aged.com/api/get-one-prestataire" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.services4aged.com/api/get-one-prestataire"
);

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

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

url = 'https://api.services4aged.com/api/get-one-prestataire'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  '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/get-one-prestataire

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Update prestataire

requires authentication

Example request:
curl --request POST \
    "https://api.services4aged.com/api/update-prestataire" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: multipart/form-data" \
    --header "Accept: application/json" \
    --form "name=John"\
    --form "last_name=Doe"\
    --form "phone=696661135"\
    --form "lang=quis"\
    --form "country_residence=Cameroun"\
    --form "city_residence=Yaoundé"\
    --form "date_birth=1996-03-11"\
    --form "accept_term_condition="\
    --form "professional_experience=eos"\
    --form "specific_skill=cum"\
    --form "cni_number=737796.79256091"\
    --form "category_prestataire_id=2433.7"\
    --form "profession_id=205386.05"\
    --form "photo=@/tmp/phpWrkCX8" 
const url = new URL(
    "https://api.services4aged.com/api/update-prestataire"
);

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

const body = new FormData();
body.append('name', 'John');
body.append('last_name', 'Doe');
body.append('phone', '696661135');
body.append('lang', 'quis');
body.append('country_residence', 'Cameroun');
body.append('city_residence', 'Yaoundé');
body.append('date_birth', '1996-03-11');
body.append('accept_term_condition', '');
body.append('professional_experience', 'eos');
body.append('specific_skill', 'cum');
body.append('cni_number', '737796.79256091');
body.append('category_prestataire_id', '2433.7');
body.append('profession_id', '205386.05');
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 = 'https://api.services4aged.com/api/update-prestataire';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'multipart/form-data',
            'Accept' => 'application/json',
        ],
        'multipart' => [
            [
                'name' => 'name',
                'contents' => 'John'
            ],
            [
                'name' => 'last_name',
                'contents' => 'Doe'
            ],
            [
                'name' => 'phone',
                'contents' => '696661135'
            ],
            [
                'name' => 'lang',
                'contents' => 'quis'
            ],
            [
                'name' => 'country_residence',
                'contents' => 'Cameroun'
            ],
            [
                'name' => 'city_residence',
                'contents' => 'Yaoundé'
            ],
            [
                'name' => 'date_birth',
                'contents' => '1996-03-11'
            ],
            [
                'name' => 'accept_term_condition',
                'contents' => ''
            ],
            [
                'name' => 'professional_experience',
                'contents' => 'eos'
            ],
            [
                'name' => 'specific_skill',
                'contents' => 'cum'
            ],
            [
                'name' => 'cni_number',
                'contents' => '737796.79256091'
            ],
            [
                'name' => 'category_prestataire_id',
                'contents' => '2433.7'
            ],
            [
                'name' => 'profession_id',
                'contents' => '205386.05'
            ],
            [
                'name' => 'photo',
                'contents' => fopen('/tmp/phpWrkCX8', 'r')
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.services4aged.com/api/update-prestataire'
files = {
  'name': (None, 'John'),
  'last_name': (None, 'Doe'),
  'phone': (None, '696661135'),
  'lang': (None, 'quis'),
  'country_residence': (None, 'Cameroun'),
  'city_residence': (None, 'Yaoundé'),
  'date_birth': (None, '1996-03-11'),
  'accept_term_condition': (None, ''),
  'professional_experience': (None, 'eos'),
  'specific_skill': (None, 'cum'),
  'cni_number': (None, '737796.79256091'),
  'category_prestataire_id': (None, '2433.7'),
  'profession_id': (None, '205386.05'),
  'photo': open('/tmp/phpWrkCX8', 'rb')}
payload = {
    "name": "John",
    "last_name": "Doe",
    "phone": "696661135",
    "lang": "quis",
    "country_residence": "Cameroun",
    "city_residence": "Yaoundé",
    "date_birth": "1996-03-11",
    "accept_term_condition": false,
    "professional_experience": "eos",
    "specific_skill": "cum",
    "cni_number": 737796.792560907,
    "category_prestataire_id": 2433.7,
    "profession_id": 205386.05
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'multipart/form-data',
  'Accept': 'application/json'
}

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

Request      

POST api/update-prestataire

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: multipart/form-data

Accept      

Example: application/json

Body Parameters

name   string  optional  

name of user. Must not be greater than 255 characters. Example: John

last_name   string  optional  

name of user. Must not be greater than 255 characters. Example: Doe

phone   string  optional  

phone of user. Must not be greater than 14 characters. Example: 696661135

lang   string  optional  

Example: quis

photo   file  optional  

Must be an image. Must not be greater than 2048 kilobytes. Example: /tmp/phpWrkCX8

country_residence   string  optional  

Pays de résidence. Example: Cameroun

city_residence   string  optional  

Ville de résidence. Example: Yaoundé

date_birth   string  optional  

Date de naissance. Must be a valid date. Example: 1996-03-11

accept_term_condition   boolean   

Example: false

professional_experience   string  optional  

Example: eos

shool_level   string  optional  
specific_skill   string  optional  

Example: cum

speciality   string  optional  
cni_number   number  optional  

Example: 737796.79256091

category_prestataire_id   number  optional  

Example: 2433.7

profession_id   number  optional  

Example: 205386.05

Module Souscripteur

GET api/get-beneficiary-details/{id}

requires authentication

Example request:
curl --request GET \
    --get "https://api.services4aged.com/api/get-beneficiary-details/natus" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.services4aged.com/api/get-beneficiary-details/natus"
);

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

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

url = 'https://api.services4aged.com/api/get-beneficiary-details/natus'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  '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/get-beneficiary-details/{id}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

id   string   

The ID of the get beneficiary detail. Example: natus

PATCH api/restrict-souscripteur/{souscripteur_id}

requires authentication

Example request:
curl --request PATCH \
    "https://api.services4aged.com/api/restrict-souscripteur/blanditiis" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.services4aged.com/api/restrict-souscripteur/blanditiis"
);

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

fetch(url, {
    method: "PATCH",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.services4aged.com/api/restrict-souscripteur/blanditiis';
$response = $client->patch(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.services4aged.com/api/restrict-souscripteur/blanditiis'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Request      

PATCH api/restrict-souscripteur/{souscripteur_id}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

souscripteur_id   string   

The ID of the souscripteur. Example: blanditiis

Creer un souscripteur

requires authentication

Example request:
curl --request POST \
    "https://api.services4aged.com/api/create-soubscripteur" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: multipart/form-data" \
    --header "Accept: application/json" \
    --form "name=John"\
    --form "last_name=Doe"\
    --form "phone=696661135"\
    --form "country_residence=Cameroun"\
    --form "city_residence=Yaoundé"\
    --form "date_birth=1996-03-11"\
    --form "lang=en"\
    --form "accept_term_condition=1"\
    --form "email=nativemind@google.com"\
    --form "password=Admin@1234"\
    --form "password_confirmation=Admin@1234"\
    --form "photo=@/tmp/php3Z8o8S" 
const url = new URL(
    "https://api.services4aged.com/api/create-soubscripteur"
);

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

const body = new FormData();
body.append('name', 'John');
body.append('last_name', 'Doe');
body.append('phone', '696661135');
body.append('country_residence', 'Cameroun');
body.append('city_residence', 'Yaoundé');
body.append('date_birth', '1996-03-11');
body.append('lang', 'en');
body.append('accept_term_condition', '1');
body.append('email', 'nativemind@google.com');
body.append('password', 'Admin@1234');
body.append('password_confirmation', 'Admin@1234');
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 = 'https://api.services4aged.com/api/create-soubscripteur';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'multipart/form-data',
            'Accept' => 'application/json',
        ],
        'multipart' => [
            [
                'name' => 'name',
                'contents' => 'John'
            ],
            [
                'name' => 'last_name',
                'contents' => 'Doe'
            ],
            [
                'name' => 'phone',
                'contents' => '696661135'
            ],
            [
                'name' => 'country_residence',
                'contents' => 'Cameroun'
            ],
            [
                'name' => 'city_residence',
                'contents' => 'Yaoundé'
            ],
            [
                'name' => 'date_birth',
                'contents' => '1996-03-11'
            ],
            [
                'name' => 'lang',
                'contents' => 'en'
            ],
            [
                'name' => 'accept_term_condition',
                'contents' => '1'
            ],
            [
                'name' => 'email',
                'contents' => 'nativemind@google.com'
            ],
            [
                'name' => 'password',
                'contents' => 'Admin@1234'
            ],
            [
                'name' => 'password_confirmation',
                'contents' => 'Admin@1234'
            ],
            [
                'name' => 'photo',
                'contents' => fopen('/tmp/php3Z8o8S', 'r')
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.services4aged.com/api/create-soubscripteur'
files = {
  'name': (None, 'John'),
  'last_name': (None, 'Doe'),
  'phone': (None, '696661135'),
  'country_residence': (None, 'Cameroun'),
  'city_residence': (None, 'Yaoundé'),
  'date_birth': (None, '1996-03-11'),
  'lang': (None, 'en'),
  'accept_term_condition': (None, '1'),
  'email': (None, 'nativemind@google.com'),
  'password': (None, 'Admin@1234'),
  'password_confirmation': (None, 'Admin@1234'),
  'photo': open('/tmp/php3Z8o8S', 'rb')}
payload = {
    "name": "John",
    "last_name": "Doe",
    "phone": "696661135",
    "country_residence": "Cameroun",
    "city_residence": "Yaoundé",
    "date_birth": "1996-03-11",
    "lang": "en",
    "accept_term_condition": true,
    "email": "nativemind@google.com",
    "password": "Admin@1234",
    "password_confirmation": "Admin@1234"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'multipart/form-data',
  'Accept': 'application/json'
}

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

Request      

POST api/create-soubscripteur

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: multipart/form-data

Accept      

Example: application/json

Body Parameters

name   string   

name of user. Must not be greater than 255 characters. Example: John

last_name   string   

name of user. Must not be greater than 255 characters. Example: Doe

phone   string   

phone of user. Must not be greater than 14 characters. Example: 696661135

photo   file  optional  

Must be an image. Must not be greater than 2048 kilobytes. Example: /tmp/php3Z8o8S

country_residence   string   

Pays de résidence. Example: Cameroun

city_residence   string   

Ville de résidence. Example: Yaoundé

date_birth   string   

Date de naissance. Must be a valid date. Example: 1996-03-11

lang   string   

Example: en

Must be one of:
  • en
  • fr
accept_term_condition   boolean   

Must be accepted. Example: true

email   string   

email of user. Must be a valid email address. Must not be greater than 255 characters. Example: nativemind@google.com

password   string   

password of user. Example: Admin@1234

password_confirmation   string   

confirm password of user. Example: Admin@1234

Liste beneficiaire souscripteur

requires authentication

Example request:
curl --request GET \
    --get "https://api.services4aged.com/api/get-beneficiary" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.services4aged.com/api/get-beneficiary"
);

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

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

url = 'https://api.services4aged.com/api/get-beneficiary'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  '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/get-beneficiary

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Delete Beneficiary

requires authentication

Example request:
curl --request DELETE \
    "https://api.services4aged.com/api/delete-beneficiary/cumque" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.services4aged.com/api/delete-beneficiary/cumque"
);

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

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.services4aged.com/api/delete-beneficiary/cumque';
$response = $client->delete(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.services4aged.com/api/delete-beneficiary/cumque'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Request      

DELETE api/delete-beneficiary/{id}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

id   string   

The ID of the delete beneficiary. Example: cumque

Metre à jour un souscripteur

requires authentication

Example request:
curl --request PATCH \
    "https://api.services4aged.com/api/update-souscripteur-information" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: multipart/form-data" \
    --header "Accept: application/json" \
    --form "name=John"\
    --form "last_name=Doe"\
    --form "phone=696661135"\
    --form "country_residence=Cameroun"\
    --form "city_residence=Yaoundé"\
    --form "date_birth=1996-03-11"\
    --form "email=nativemind@google.com"\
    --form "password=Admin@1234"\
    --form "lang=temporibus"\
    --form "photo=@/tmp/phpk4S1xb" \
    --form "file_antecedent_medicaux=@/tmp/phpUC1sVk" 
const url = new URL(
    "https://api.services4aged.com/api/update-souscripteur-information"
);

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

const body = new FormData();
body.append('name', 'John');
body.append('last_name', 'Doe');
body.append('phone', '696661135');
body.append('country_residence', 'Cameroun');
body.append('city_residence', 'Yaoundé');
body.append('date_birth', '1996-03-11');
body.append('email', 'nativemind@google.com');
body.append('password', 'Admin@1234');
body.append('lang', 'temporibus');
body.append('photo', document.querySelector('input[name="photo"]').files[0]);
body.append('file_antecedent_medicaux', document.querySelector('input[name="file_antecedent_medicaux"]').files[0]);

fetch(url, {
    method: "PATCH",
    headers,
    body,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.services4aged.com/api/update-souscripteur-information';
$response = $client->patch(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'multipart/form-data',
            'Accept' => 'application/json',
        ],
        'multipart' => [
            [
                'name' => 'name',
                'contents' => 'John'
            ],
            [
                'name' => 'last_name',
                'contents' => 'Doe'
            ],
            [
                'name' => 'phone',
                'contents' => '696661135'
            ],
            [
                'name' => 'country_residence',
                'contents' => 'Cameroun'
            ],
            [
                'name' => 'city_residence',
                'contents' => 'Yaoundé'
            ],
            [
                'name' => 'date_birth',
                'contents' => '1996-03-11'
            ],
            [
                'name' => 'email',
                'contents' => 'nativemind@google.com'
            ],
            [
                'name' => 'password',
                'contents' => 'Admin@1234'
            ],
            [
                'name' => 'lang',
                'contents' => 'temporibus'
            ],
            [
                'name' => 'photo',
                'contents' => fopen('/tmp/phpk4S1xb', 'r')
            ],
            [
                'name' => 'file_antecedent_medicaux',
                'contents' => fopen('/tmp/phpUC1sVk', 'r')
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.services4aged.com/api/update-souscripteur-information'
files = {
  'name': (None, 'John'),
  'last_name': (None, 'Doe'),
  'phone': (None, '696661135'),
  'country_residence': (None, 'Cameroun'),
  'city_residence': (None, 'Yaoundé'),
  'date_birth': (None, '1996-03-11'),
  'email': (None, 'nativemind@google.com'),
  'password': (None, 'Admin@1234'),
  'lang': (None, 'temporibus'),
  'photo': open('/tmp/phpk4S1xb', 'rb'),
  'file_antecedent_medicaux': open('/tmp/phpUC1sVk', 'rb')}
payload = {
    "name": "John",
    "last_name": "Doe",
    "phone": "696661135",
    "country_residence": "Cameroun",
    "city_residence": "Yaoundé",
    "date_birth": "1996-03-11",
    "email": "nativemind@google.com",
    "password": "Admin@1234",
    "lang": "temporibus"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'multipart/form-data',
  'Accept': 'application/json'
}

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

Request      

PATCH api/update-souscripteur-information

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: multipart/form-data

Accept      

Example: application/json

Body Parameters

name   string  optional  

name of user. Must not be greater than 255 characters. Example: John

beneficiary_id   string  optional  
last_name   string  optional  

name of user. Must not be greater than 255 characters. Example: Doe

phone   string  optional  

phone of user. Must not be greater than 14 characters. Example: 696661135

photo   file  optional  

Must be an image. Must not be greater than 2048 kilobytes. Example: /tmp/phpk4S1xb

file_antecedent_medicaux   file  optional  

Must be a file. Must not be greater than 2048 kilobytes. Example: /tmp/phpUC1sVk

country_residence   string  optional  

Pays de résidence. Example: Cameroun

city_residence   string  optional  

Ville de résidence. Example: Yaoundé

date_birth   string  optional  

Date de naissance. Must be a valid date. Example: 1996-03-11

email   string  optional  

email of user. Must be a valid email address. Must not be greater than 255 characters. Example: nativemind@google.com

password   string  optional  

password of user. Example: Admin@1234

lang   string  optional  

Example: temporibus

Remove restrict souscripteur

requires authentication

Example request:
curl --request PATCH \
    "https://api.services4aged.com/api/remove-restriction/ut" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.services4aged.com/api/remove-restriction/ut"
);

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

fetch(url, {
    method: "PATCH",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.services4aged.com/api/remove-restriction/ut';
$response = $client->patch(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.services4aged.com/api/remove-restriction/ut'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Request      

PATCH api/remove-restriction/{souscripteur_id}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

souscripteur_id   string   

The ID of the souscripteur. Example: ut

Module Partenaire

Inscription d'un partenaire

requires authentication

Example request:
curl --request POST \
    "https://api.services4aged.com/api/create-partenaire" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: multipart/form-data" \
    --header "Accept: application/json" \
    --form "name=John"\
    --form "last_name=Doe"\
    --form "phone=696661135"\
    --form "country_residence=Cameroun"\
    --form "city_residence=Yaoundé"\
    --form "date_birth=1996-03-11"\
    --form "lang=en"\
    --form "accept_term_condition=1"\
    --form "email=nativemind@google.com"\
    --form "password=Admin@1234"\
    --form "password_confirmation=Admin@1234"\
    --form "photo=@/tmp/phpwcsz1V" 
const url = new URL(
    "https://api.services4aged.com/api/create-partenaire"
);

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

const body = new FormData();
body.append('name', 'John');
body.append('last_name', 'Doe');
body.append('phone', '696661135');
body.append('country_residence', 'Cameroun');
body.append('city_residence', 'Yaoundé');
body.append('date_birth', '1996-03-11');
body.append('lang', 'en');
body.append('accept_term_condition', '1');
body.append('email', 'nativemind@google.com');
body.append('password', 'Admin@1234');
body.append('password_confirmation', 'Admin@1234');
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 = 'https://api.services4aged.com/api/create-partenaire';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'multipart/form-data',
            'Accept' => 'application/json',
        ],
        'multipart' => [
            [
                'name' => 'name',
                'contents' => 'John'
            ],
            [
                'name' => 'last_name',
                'contents' => 'Doe'
            ],
            [
                'name' => 'phone',
                'contents' => '696661135'
            ],
            [
                'name' => 'country_residence',
                'contents' => 'Cameroun'
            ],
            [
                'name' => 'city_residence',
                'contents' => 'Yaoundé'
            ],
            [
                'name' => 'date_birth',
                'contents' => '1996-03-11'
            ],
            [
                'name' => 'lang',
                'contents' => 'en'
            ],
            [
                'name' => 'accept_term_condition',
                'contents' => '1'
            ],
            [
                'name' => 'email',
                'contents' => 'nativemind@google.com'
            ],
            [
                'name' => 'password',
                'contents' => 'Admin@1234'
            ],
            [
                'name' => 'password_confirmation',
                'contents' => 'Admin@1234'
            ],
            [
                'name' => 'photo',
                'contents' => fopen('/tmp/phpwcsz1V', 'r')
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.services4aged.com/api/create-partenaire'
files = {
  'name': (None, 'John'),
  'last_name': (None, 'Doe'),
  'phone': (None, '696661135'),
  'country_residence': (None, 'Cameroun'),
  'city_residence': (None, 'Yaoundé'),
  'date_birth': (None, '1996-03-11'),
  'lang': (None, 'en'),
  'accept_term_condition': (None, '1'),
  'email': (None, 'nativemind@google.com'),
  'password': (None, 'Admin@1234'),
  'password_confirmation': (None, 'Admin@1234'),
  'photo': open('/tmp/phpwcsz1V', 'rb')}
payload = {
    "name": "John",
    "last_name": "Doe",
    "phone": "696661135",
    "country_residence": "Cameroun",
    "city_residence": "Yaoundé",
    "date_birth": "1996-03-11",
    "lang": "en",
    "accept_term_condition": true,
    "email": "nativemind@google.com",
    "password": "Admin@1234",
    "password_confirmation": "Admin@1234"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'multipart/form-data',
  'Accept': 'application/json'
}

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

Request      

POST api/create-partenaire

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: multipart/form-data

Accept      

Example: application/json

Body Parameters

name   string   

name of user. Must not be greater than 255 characters. Example: John

last_name   string   

name of user. Must not be greater than 255 characters. Example: Doe

phone   string   

phone of user. Must not be greater than 14 characters. Example: 696661135

photo   file  optional  

Must be an image. Must not be greater than 2048 kilobytes. Example: /tmp/phpwcsz1V

country_residence   string   

Pays de résidence. Example: Cameroun

city_residence   string   

Ville de résidence. Example: Yaoundé

date_birth   string   

Date de naissance. Must be a valid date. Example: 1996-03-11

lang   string   

Example: en

Must be one of:
  • en
  • fr
accept_term_condition   boolean   

Must be accepted. Example: true

email   string   

email of user. Must be a valid email address. Must not be greater than 255 characters. Example: nativemind@google.com

password   string   

password of user. Example: Admin@1234

password_confirmation   string   

confirm password of user. Example: Admin@1234

Module package

GET api/package-details/{id}

requires authentication

Example request:
curl --request GET \
    --get "https://api.services4aged.com/api/package-details/eveniet" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.services4aged.com/api/package-details/eveniet"
);

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

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

url = 'https://api.services4aged.com/api/package-details/eveniet'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (404):

Show headers 
cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 60
x-ratelimit-remaining: 58
vary: Origin
 

{
    "status": false,
    "errors": [],
    "message": "Package not found"
}

Request      

GET api/package-details/{id}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

id   string   

The ID of the package detail. Example: eveniet

Get all package

requires authentication

Example request:
curl --request GET \
    --get "https://api.services4aged.com/api/list-all-package" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.services4aged.com/api/list-all-package"
);

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

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

url = 'https://api.services4aged.com/api/list-all-package'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200):

Show headers 
cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 60
x-ratelimit-remaining: 59
vary: Origin
 

{
    "status": true,
    "data": {
        "packages": [
            {
                "id": 1,
                "title": "Offre De Base",
                "category_prestation_id": 4,
                "missions": "aide soignante sexy",
                "price": 3000,
                "duration": 30,
                "created_at": "2023-09-05T23:20:48.000000Z",
                "updated_at": "2023-09-05T23:20:48.000000Z"
            },
            {
                "id": 2,
                "title": "Offre Bonus",
                "category_prestation_id": 1,
                "missions": "Réaliser des courses une fois par semaine. Le coût du panier à la charge du souscripteur",
                "price": 40000,
                "duration": 30,
                "created_at": "2023-09-20T03:58:34.000000Z",
                "updated_at": "2023-09-20T03:58:34.000000Z"
            },
            {
                "id": 3,
                "title": "Offre Premium",
                "category_prestation_id": 2,
                "missions": "Offre de Base\r\n Offre S4A3 : Consultation à domicile une fois par mois\r\n Offre S4A2 : Hygiène de vie et soin corporelle une fois par semaine",
                "price": 50000,
                "duration": 30,
                "created_at": "2023-09-20T02:55:20.000000Z",
                "updated_at": "2023-09-20T03:58:34.000000Z"
            },
            {
                "id": 4,
                "title": "Offre Platinum",
                "category_prestation_id": 4,
                "missions": "Offre Platinum\r\nOffre de Base\r\n Offre S4A3 : Consultation à domicile une fois par mois\r\n Offre S4A2 : Hygiène de vie et soin corporelle une fois par semaine\r\n Offre S4A5 : Loisir et vie sociale une fois par semaine",
                "price": 100000,
                "duration": 30,
                "created_at": "2023-09-20T03:58:34.000000Z",
                "updated_at": "2023-09-20T02:55:20.000000Z"
            }
        ]
    },
    "message": "Package charged successfully"
}

Request      

GET api/list-all-package

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Create package

requires authentication

Example request:
curl --request GET \
    --get "https://api.services4aged.com/api/create-package" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"title\": \"Premium\",
    \"category_prestation_id\": 2,
    \"missions\": \"Guard patient\",
    \"price\": 5000,
    \"duration\": 8
}"

const url = new URL(
    "https://api.services4aged.com/api/create-package"
);

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

let body = {
    "title": "Premium",
    "category_prestation_id": 2,
    "missions": "Guard patient",
    "price": 5000,
    "duration": 8
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.services4aged.com/api/create-package';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'title' => 'Premium',
            'category_prestation_id' => 2,
            'missions' => 'Guard patient',
            'price' => 5000,
            'duration' => 8,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.services4aged.com/api/create-package'
payload = {
    "title": "Premium",
    "category_prestation_id": 2,
    "missions": "Guard patient",
    "price": 5000,
    "duration": 8
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (401):

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

{
    "message": "Unauthenticated."
}

Request      

GET api/create-package

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

title   string   

Enter title. Example: Premium

category_prestation_id   integer   

Enter category prestation id. Example: 2

missions   string   

Enter all missions. Example: Guard patient

price   integer   

Enter price. Example: 5000

duration   integer   

Example: 8

Module Authentification

POST api/verify-token

requires authentication

Example request:
curl --request POST \
    "https://api.services4aged.com/api/verify-token" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.services4aged.com/api/verify-token"
);

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

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.services4aged.com/api/verify-token';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.services4aged.com/api/verify-token'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Request      

POST api/verify-token

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

POST api/logout

requires authentication

Example request:
curl --request POST \
    "https://api.services4aged.com/api/logout" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.services4aged.com/api/logout"
);

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

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.services4aged.com/api/logout';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.services4aged.com/api/logout'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Request      

POST api/logout

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

POST api/login

Example request:
curl --request POST \
    "https://api.services4aged.com/api/login" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"email\": \"jrunolfsdottir@example.net\",
    \"password\": \"N&:lODQ>[9=G\\/Qe{p\"
}"

const url = new URL(
    "https://api.services4aged.com/api/login"
);

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

let body = {
    "email": "jrunolfsdottir@example.net",
    "password": "N&:lODQ>[9=G\/Qe{p"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.services4aged.com/api/login';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'email' => 'jrunolfsdottir@example.net',
            'password' => 'N&:lODQ>[9=G/Qe{p',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.services4aged.com/api/login'
payload = {
    "email": "jrunolfsdottir@example.net",
    "password": "N&:lODQ>[9=G\/Qe{p"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Request      

POST api/login

Headers

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

email   string   

Must be a valid email address. Example: jrunolfsdottir@example.net

password   string   

Example: N&:lODQ>[9=G/Qe{p

POST api/forgot-password

Example request:
curl --request POST \
    "https://api.services4aged.com/api/forgot-password" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"email\": \"heaney.mossie@example.net\",
    \"device\": \"rerum\"
}"

const url = new URL(
    "https://api.services4aged.com/api/forgot-password"
);

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

let body = {
    "email": "heaney.mossie@example.net",
    "device": "rerum"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.services4aged.com/api/forgot-password';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'email' => 'heaney.mossie@example.net',
            'device' => 'rerum',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.services4aged.com/api/forgot-password'
payload = {
    "email": "heaney.mossie@example.net",
    "device": "rerum"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Request      

POST api/forgot-password

Headers

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

email   string   

Must be a valid email address. Example: heaney.mossie@example.net

device   string   

Example: rerum

POST api/verify-otp-password

requires authentication

Example request:
curl --request POST \
    "https://api.services4aged.com/api/verify-otp-password" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"email\": \"myrl70@example.com\",
    \"otp\": \"non\"
}"

const url = new URL(
    "https://api.services4aged.com/api/verify-otp-password"
);

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

let body = {
    "email": "myrl70@example.com",
    "otp": "non"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.services4aged.com/api/verify-otp-password';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'email' => 'myrl70@example.com',
            'otp' => 'non',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.services4aged.com/api/verify-otp-password'
payload = {
    "email": "myrl70@example.com",
    "otp": "non"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Request      

POST api/verify-otp-password

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

email   string   

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

otp   string   

Example: non

POST api/reset-password

Example request:
curl --request POST \
    "https://api.services4aged.com/api/reset-password" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"device\": \"web\",
    \"email\": \"raegan27@example.org\",
    \"password\": \"doloribus\"
}"

const url = new URL(
    "https://api.services4aged.com/api/reset-password"
);

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

let body = {
    "device": "web",
    "email": "raegan27@example.org",
    "password": "doloribus"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.services4aged.com/api/reset-password';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'device' => 'web',
            'email' => 'raegan27@example.org',
            'password' => 'doloribus',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.services4aged.com/api/reset-password'
payload = {
    "device": "web",
    "email": "raegan27@example.org",
    "password": "doloribus"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Request      

POST api/reset-password

Headers

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

token   string  optional  
device   string   

Example: web

Must be one of:
  • mobile
  • web
email   string   

Must be a valid email address. Example: raegan27@example.org

password   string   

Example: doloribus

Verify email

requires authentication

Example request:
curl --request GET \
    --get "https://api.services4aged.com/api/verify-email/in/cupiditate" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.services4aged.com/api/verify-email/in/cupiditate"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.services4aged.com/api/verify-email/in/cupiditate';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.services4aged.com/api/verify-email/in/cupiditate'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  '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/verify-email/{id}/{hash}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

id   string   

The ID of the verify email. Example: in

hash   string   

Example: cupiditate

Resend email verification

requires authentication

Example request:
curl --request POST \
    "https://api.services4aged.com/api/email/resend-verification-notification" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.services4aged.com/api/email/resend-verification-notification"
);

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

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.services4aged.com/api/email/resend-verification-notification';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.services4aged.com/api/email/resend-verification-notification'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Request      

POST api/email/resend-verification-notification

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

User management

POST api/check-exist-email

requires authentication

Example request:
curl --request POST \
    "https://api.services4aged.com/api/check-exist-email" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"email\": \"hagenes.dandre@example.org\"
}"

const url = new URL(
    "https://api.services4aged.com/api/check-exist-email"
);

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

let body = {
    "email": "hagenes.dandre@example.org"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.services4aged.com/api/check-exist-email';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'email' => 'hagenes.dandre@example.org',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.services4aged.com/api/check-exist-email'
payload = {
    "email": "hagenes.dandre@example.org"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Request      

POST api/check-exist-email

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

email   string   

Must be a valid email address. Example: hagenes.dandre@example.org

Display the specified User information.

requires authentication

Example request:
curl --request GET \
    --get "https://api.services4aged.com/api/user/auth" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.services4aged.com/api/user/auth"
);

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

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

url = 'https://api.services4aged.com/api/user/auth'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  '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/auth

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Update the User information

requires authentication

Example request:
curl --request POST \
    "https://api.services4aged.com/api/user-update-info" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.services4aged.com/api/user-update-info"
);

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

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.services4aged.com/api/user-update-info';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.services4aged.com/api/user-update-info'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Request      

POST api/user-update-info

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Change Avatar user

requires authentication

Example request:
curl --request POST \
    "https://api.services4aged.com/api/change-avatar" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: multipart/form-data" \
    --header "Accept: application/json" \
    --form "photo=@/tmp/phplLHQuQ" 
const url = new URL(
    "https://api.services4aged.com/api/change-avatar"
);

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

const body = new FormData();
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 = 'https://api.services4aged.com/api/change-avatar';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'multipart/form-data',
            'Accept' => 'application/json',
        ],
        'multipart' => [
            [
                'name' => 'photo',
                'contents' => fopen('/tmp/phplLHQuQ', 'r')
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.services4aged.com/api/change-avatar'
files = {
  'photo': open('/tmp/phplLHQuQ', 'rb')}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'multipart/form-data',
  'Accept': 'application/json'
}

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

Request      

POST api/change-avatar

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: multipart/form-data

Accept      

Example: application/json

Body Parameters

photo   file  optional  

Must be an image. Must not be greater than 3072 kilobytes. Example: /tmp/phplLHQuQ

Verify email with otp code

requires authentication

Example request:
curl --request POST \
    "https://api.services4aged.com/api/verify-email-with-otp" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.services4aged.com/api/verify-email-with-otp"
);

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

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.services4aged.com/api/verify-email-with-otp';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.services4aged.com/api/verify-email-with-otp'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Request      

POST api/verify-email-with-otp

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Module administrateur

Liste des prestataires inactif

requires authentication

Example request:
curl --request GET \
    --get "https://api.services4aged.com/api/get-unactived-prestataire" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.services4aged.com/api/get-unactived-prestataire"
);

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

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

url = 'https://api.services4aged.com/api/get-unactived-prestataire'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  '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/get-unactived-prestataire

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Activer un prestataire

requires authentication

Example request:
curl --request POST \
    "https://api.services4aged.com/api/active-prestataire" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"prestataire_id\": 16
}"

const url = new URL(
    "https://api.services4aged.com/api/active-prestataire"
);

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

let body = {
    "prestataire_id": 16
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.services4aged.com/api/active-prestataire';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'prestataire_id' => 16,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.services4aged.com/api/active-prestataire'
payload = {
    "prestataire_id": 16
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Request      

POST api/active-prestataire

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

prestataire_id   integer   

Example: 16

Désactiver un prestataire

requires authentication

Example request:
curl --request POST \
    "https://api.services4aged.com/api/unactive-prestataire" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"prestataire_id\": 2
}"

const url = new URL(
    "https://api.services4aged.com/api/unactive-prestataire"
);

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

let body = {
    "prestataire_id": 2
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.services4aged.com/api/unactive-prestataire';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'prestataire_id' => 2,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.services4aged.com/api/unactive-prestataire'
payload = {
    "prestataire_id": 2
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Request      

POST api/unactive-prestataire

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

prestataire_id   integer   

Example: 2

Liste des prestataires

requires authentication

Example request:
curl --request GET \
    --get "https://api.services4aged.com/api/get-all-prestataire" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.services4aged.com/api/get-all-prestataire"
);

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

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

url = 'https://api.services4aged.com/api/get-all-prestataire'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  '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/get-all-prestataire

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Liste prestation non cloturer

requires authentication

Example request:
curl --request GET \
    --get "https://api.services4aged.com/api/list-prestation-assigner" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.services4aged.com/api/list-prestation-assigner"
);

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

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

url = 'https://api.services4aged.com/api/list-prestation-assigner'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  '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/list-prestation-assigner

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Liste prestation en attente

requires authentication

Example request:
curl --request GET \
    --get "https://api.services4aged.com/api/list-prestation-en-attente" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.services4aged.com/api/list-prestation-en-attente"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.services4aged.com/api/list-prestation-en-attente';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.services4aged.com/api/list-prestation-en-attente'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  '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/list-prestation-en-attente

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Assigner prestation

requires authentication

Example request:
curl --request POST \
    "https://api.services4aged.com/api/assign-prestataire" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"prestation_id\": 1,
    \"prestataire_id\": 18
}"

const url = new URL(
    "https://api.services4aged.com/api/assign-prestataire"
);

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

let body = {
    "prestation_id": 1,
    "prestataire_id": 18
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.services4aged.com/api/assign-prestataire';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'prestation_id' => 1,
            'prestataire_id' => 18,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.services4aged.com/api/assign-prestataire'
payload = {
    "prestation_id": 1,
    "prestataire_id": 18
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Request      

POST api/assign-prestataire

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

prestation_id   integer   

Example: 1

prestataire_id   integer   

Example: 18

Module prestation

Confirmed Prestation by admin.

requires authentication

Example request:
curl --request PATCH \
    "https://api.services4aged.com/api/isConfirmed/voluptate" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"isConfirmed\": false
}"

const url = new URL(
    "https://api.services4aged.com/api/isConfirmed/voluptate"
);

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

let body = {
    "isConfirmed": false
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.services4aged.com/api/isConfirmed/voluptate';
$response = $client->patch(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'isConfirmed' => false,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.services4aged.com/api/isConfirmed/voluptate'
payload = {
    "isConfirmed": false
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Request      

PATCH api/isConfirmed/{prestation_id}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

prestation_id   string   

The ID of the prestation. Example: voluptate

Body Parameters

isConfirmed   boolean   

Example: false

listing available prestation by prestataire

requires authentication

Example request:
curl --request GET \
    --get "https://api.services4aged.com/api/isAvailablePrestation" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.services4aged.com/api/isAvailablePrestation"
);

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

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

url = 'https://api.services4aged.com/api/isAvailablePrestation'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  '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/isAvailablePrestation

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Close Prestation.

requires authentication

Example request:
curl --request POST \
    "https://api.services4aged.com/api/isClosed/occaecati" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"isClosed\": true
}"

const url = new URL(
    "https://api.services4aged.com/api/isClosed/occaecati"
);

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

let body = {
    "isClosed": true
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.services4aged.com/api/isClosed/occaecati';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'isClosed' => true,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.services4aged.com/api/isClosed/occaecati'
payload = {
    "isClosed": true
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Request      

POST api/isClosed/{id}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

id   string   

The ID of the isClosed. Example: occaecati

Body Parameters

isClosed   boolean   

Example: true

Candidate Prestation.

requires authentication

Example request:
curl --request POST \
    "https://api.services4aged.com/api/isCandidate/earum" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"isAvailable\": true
}"

const url = new URL(
    "https://api.services4aged.com/api/isCandidate/earum"
);

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

let body = {
    "isAvailable": true
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.services4aged.com/api/isCandidate/earum';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'isAvailable' => true,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.services4aged.com/api/isCandidate/earum'
payload = {
    "isAvailable": true
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Request      

POST api/isCandidate/{id}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

id   string   

The ID of the isCandidate. Example: earum

Body Parameters

isAvailable   boolean   

Example: true

Details prestataire prestation

requires authentication

Example request:
curl --request GET \
    --get "https://api.services4aged.com/api/detailsPrestation/totam" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.services4aged.com/api/detailsPrestation/totam"
);

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

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

url = 'https://api.services4aged.com/api/detailsPrestation/totam'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  '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/detailsPrestation/{id}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

id   string   

The ID of the detailsPrestation. Example: totam

Details prestataire prestation

requires authentication

Example request:
curl --request GET \
    --get "https://api.services4aged.com/api/details-patient-rapport/sed/quia" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.services4aged.com/api/details-patient-rapport/sed/quia"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.services4aged.com/api/details-patient-rapport/sed/quia';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.services4aged.com/api/details-patient-rapport/sed/quia'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  '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/details-patient-rapport/{id}/{patient_id}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

id   string   

The ID of the details patient rapport. Example: sed

patient_id   string   

The ID of the patient. Example: quia

Pending prestataire prestation

requires authentication

Example request:
curl --request GET \
    --get "https://api.services4aged.com/api/listPendingPrestation" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.services4aged.com/api/listPendingPrestation"
);

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

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

url = 'https://api.services4aged.com/api/listPendingPrestation'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  '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/listPendingPrestation

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Search prestation

requires authentication

Example request:
curl --request GET \
    --get "https://api.services4aged.com/api/searchPrestations/dolores" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.services4aged.com/api/searchPrestations/dolores"
);

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

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

url = 'https://api.services4aged.com/api/searchPrestations/dolores'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  '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/searchPrestations/{search?}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

search   string  optional  

Example: dolores

Follow prestation

requires authentication

Example request:
curl --request GET \
    --get "https://api.services4aged.com/api/suivi-prestation-by-prestataire" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.services4aged.com/api/suivi-prestation-by-prestataire"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.services4aged.com/api/suivi-prestation-by-prestataire';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.services4aged.com/api/suivi-prestation-by-prestataire'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  '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/suivi-prestation-by-prestataire

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Available Prestation.

requires authentication

Example request:
curl --request POST \
    "https://api.services4aged.com/api/isAvailable/aut" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"isAvailable\": false
}"

const url = new URL(
    "https://api.services4aged.com/api/isAvailable/aut"
);

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

let body = {
    "isAvailable": false
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.services4aged.com/api/isAvailable/aut';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'isAvailable' => false,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.services4aged.com/api/isAvailable/aut'
payload = {
    "isAvailable": false
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Request      

POST api/isAvailable/{id}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

id   string   

The ID of the isAvailable. Example: aut

Body Parameters

isAvailable   boolean   

Example: false

Choose Prestation.

requires authentication

Example request:
curl --request POST \
    "https://api.services4aged.com/api/createPrestation" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"beneficiaire_id\": 4,
    \"package_id\": 2,
    \"start_date\": \"01\\/07\\/2023\"
}"

const url = new URL(
    "https://api.services4aged.com/api/createPrestation"
);

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

let body = {
    "beneficiaire_id": 4,
    "package_id": 2,
    "start_date": "01\/07\/2023"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.services4aged.com/api/createPrestation';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'beneficiaire_id' => 4,
            'package_id' => 2,
            'start_date' => '01/07/2023',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.services4aged.com/api/createPrestation'
payload = {
    "beneficiaire_id": 4,
    "package_id": 2,
    "start_date": "01\/07\/2023"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Request      

POST api/createPrestation

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

beneficiaire_id   integer   

Enter beneficiaire id. Example: 4

package_id   integer   

Enter package id. Example: 2

start_date   string  optional  

Enter start date. Must be a valid date. Example: 01/07/2023

Listing prestation area nearby

requires authentication

Example request:
curl --request GET \
    --get "https://api.services4aged.com/api/get-area-prestation-nearby" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.services4aged.com/api/get-area-prestation-nearby"
);

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

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

url = 'https://api.services4aged.com/api/get-area-prestation-nearby'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  '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/get-area-prestation-nearby

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Prolonger une Prestation.

requires authentication

Example request:
curl --request POST \
    "https://api.services4aged.com/api/prolonger-prestation" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"package_id\": 2,
    \"prestation_id\": 2,
    \"start_date\": \"01\\/07\\/2023\"
}"

const url = new URL(
    "https://api.services4aged.com/api/prolonger-prestation"
);

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

let body = {
    "package_id": 2,
    "prestation_id": 2,
    "start_date": "01\/07\/2023"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.services4aged.com/api/prolonger-prestation';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'package_id' => 2,
            'prestation_id' => 2,
            'start_date' => '01/07/2023',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.services4aged.com/api/prolonger-prestation'
payload = {
    "package_id": 2,
    "prestation_id": 2,
    "start_date": "01\/07\/2023"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Request      

POST api/prolonger-prestation

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

package_id   integer   

Enter package id. Example: 2

prestation_id   integer   

Id de la prestation. Example: 2

start_date   string   

Enter start date. Must be a valid date. Example: 01/07/2023

Souscripteur prestation

requires authentication

Example request:
curl --request GET \
    --get "https://api.services4aged.com/api/list-prestation-souscripteur" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.services4aged.com/api/list-prestation-souscripteur"
);

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

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

url = 'https://api.services4aged.com/api/list-prestation-souscripteur'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  '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/list-prestation-souscripteur

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Follow prestation

requires authentication

Example request:
curl --request GET \
    --get "https://api.services4aged.com/api/suivi-prestation-by-souscripteur" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.services4aged.com/api/suivi-prestation-by-souscripteur"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.services4aged.com/api/suivi-prestation-by-souscripteur';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.services4aged.com/api/suivi-prestation-by-souscripteur'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  '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/suivi-prestation-by-souscripteur

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Super administrator management

Admin lists

requires authentication

Example request:
curl --request GET \
    --get "https://api.services4aged.com/api/liste-des-administrateurs" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.services4aged.com/api/liste-des-administrateurs"
);

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

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

url = 'https://api.services4aged.com/api/liste-des-administrateurs'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  '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/liste-des-administrateurs

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Create admin

requires authentication

Example request:
curl --request POST \
    "https://api.services4aged.com/api/creer-un-administrateur" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: multipart/form-data" \
    --header "Accept: application/json" \
    --form "name=John"\
    --form "last_name=Doe"\
    --form "phone=696661135"\
    --form "country_residence=Cameroun"\
    --form "city_residence=Yaoundé"\
    --form "date_birth=1996-03-11"\
    --form "lang=en"\
    --form "accept_term_condition=1"\
    --form "email=nativemind@google.com"\
    --form "password=Admin@1234"\
    --form "password_confirmation=Admin@1234"\
    --form "photo=@/tmp/phpwkBxqK" 
const url = new URL(
    "https://api.services4aged.com/api/creer-un-administrateur"
);

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

const body = new FormData();
body.append('name', 'John');
body.append('last_name', 'Doe');
body.append('phone', '696661135');
body.append('country_residence', 'Cameroun');
body.append('city_residence', 'Yaoundé');
body.append('date_birth', '1996-03-11');
body.append('lang', 'en');
body.append('accept_term_condition', '1');
body.append('email', 'nativemind@google.com');
body.append('password', 'Admin@1234');
body.append('password_confirmation', 'Admin@1234');
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 = 'https://api.services4aged.com/api/creer-un-administrateur';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'multipart/form-data',
            'Accept' => 'application/json',
        ],
        'multipart' => [
            [
                'name' => 'name',
                'contents' => 'John'
            ],
            [
                'name' => 'last_name',
                'contents' => 'Doe'
            ],
            [
                'name' => 'phone',
                'contents' => '696661135'
            ],
            [
                'name' => 'country_residence',
                'contents' => 'Cameroun'
            ],
            [
                'name' => 'city_residence',
                'contents' => 'Yaoundé'
            ],
            [
                'name' => 'date_birth',
                'contents' => '1996-03-11'
            ],
            [
                'name' => 'lang',
                'contents' => 'en'
            ],
            [
                'name' => 'accept_term_condition',
                'contents' => '1'
            ],
            [
                'name' => 'email',
                'contents' => 'nativemind@google.com'
            ],
            [
                'name' => 'password',
                'contents' => 'Admin@1234'
            ],
            [
                'name' => 'password_confirmation',
                'contents' => 'Admin@1234'
            ],
            [
                'name' => 'photo',
                'contents' => fopen('/tmp/phpwkBxqK', 'r')
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.services4aged.com/api/creer-un-administrateur'
files = {
  'name': (None, 'John'),
  'last_name': (None, 'Doe'),
  'phone': (None, '696661135'),
  'country_residence': (None, 'Cameroun'),
  'city_residence': (None, 'Yaoundé'),
  'date_birth': (None, '1996-03-11'),
  'lang': (None, 'en'),
  'accept_term_condition': (None, '1'),
  'email': (None, 'nativemind@google.com'),
  'password': (None, 'Admin@1234'),
  'password_confirmation': (None, 'Admin@1234'),
  'photo': open('/tmp/phpwkBxqK', 'rb')}
payload = {
    "name": "John",
    "last_name": "Doe",
    "phone": "696661135",
    "country_residence": "Cameroun",
    "city_residence": "Yaoundé",
    "date_birth": "1996-03-11",
    "lang": "en",
    "accept_term_condition": true,
    "email": "nativemind@google.com",
    "password": "Admin@1234",
    "password_confirmation": "Admin@1234"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'multipart/form-data',
  'Accept': 'application/json'
}

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

Request      

POST api/creer-un-administrateur

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: multipart/form-data

Accept      

Example: application/json

Body Parameters

name   string   

name of user. Must not be greater than 255 characters. Example: John

last_name   string   

name of user. Must not be greater than 255 characters. Example: Doe

phone   string   

phone of user. Must not be greater than 14 characters. Example: 696661135

photo   file  optional  

Must be an image. Must not be greater than 2048 kilobytes. Example: /tmp/phpwkBxqK

country_residence   string   

Pays de résidence. Example: Cameroun

city_residence   string   

Ville de résidence. Example: Yaoundé

date_birth   string   

Date de naissance. Must be a valid date. Example: 1996-03-11

lang   string   

Example: en

Must be one of:
  • en
  • fr
accept_term_condition   boolean   

Must be accepted. Example: true

email   string   

email of user. Must be a valid email address. Must not be greater than 255 characters. Example: nativemind@google.com

password   string   

password of user. Example: Admin@1234

password_confirmation   string   

confirm password of user. Example: Admin@1234

Update admin

requires authentication

Example request:
curl --request PATCH \
    "https://api.services4aged.com/api/supprimer-un-administrateur/neque" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"John\",
    \"last_name\": \"Doe\",
    \"phone\": \"696661135\",
    \"country_residence\": \"Cameroun\",
    \"city_residence\": \"Yaoundé\",
    \"date_birth\": \"1996-03-11\",
    \"email\": \"nativemind@google.com\",
    \"password\": \"Admin@1234\"
}"

const url = new URL(
    "https://api.services4aged.com/api/supprimer-un-administrateur/neque"
);

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

let body = {
    "name": "John",
    "last_name": "Doe",
    "phone": "696661135",
    "country_residence": "Cameroun",
    "city_residence": "Yaoundé",
    "date_birth": "1996-03-11",
    "email": "nativemind@google.com",
    "password": "Admin@1234"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.services4aged.com/api/supprimer-un-administrateur/neque';
$response = $client->patch(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'John',
            'last_name' => 'Doe',
            'phone' => '696661135',
            'country_residence' => 'Cameroun',
            'city_residence' => 'Yaoundé',
            'date_birth' => '1996-03-11',
            'email' => 'nativemind@google.com',
            'password' => 'Admin@1234',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.services4aged.com/api/supprimer-un-administrateur/neque'
payload = {
    "name": "John",
    "last_name": "Doe",
    "phone": "696661135",
    "country_residence": "Cameroun",
    "city_residence": "Yaoundé",
    "date_birth": "1996-03-11",
    "email": "nativemind@google.com",
    "password": "Admin@1234"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Request      

PATCH api/supprimer-un-administrateur/{id}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

id   string   

The ID of the supprimer un administrateur. Example: neque

Body Parameters

name   string  optional  

name of user. Must not be greater than 255 characters. Example: John

last_name   string  optional  

name of user. Must not be greater than 255 characters. Example: Doe

phone   string  optional  

phone of user. Must not be greater than 14 characters. Example: 696661135

image   string  optional  
country_residence   string  optional  

Pays de résidence. Example: Cameroun

city_residence   string  optional  

Ville de résidence. Example: Yaoundé

date_birth   string  optional  

Date de naissance. Must be a valid date. Example: 1996-03-11

email   string  optional  

email of user. Must be a valid email address. Must not be greater than 255 characters. Example: nativemind@google.com

password   string  optional  

password of user. Example: Admin@1234

Delete admin

requires authentication

Example request:
curl --request DELETE \
    "https://api.services4aged.com/api/modifier-un-administrateur/adipisci" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.services4aged.com/api/modifier-un-administrateur/adipisci"
);

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

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.services4aged.com/api/modifier-un-administrateur/adipisci';
$response = $client->delete(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.services4aged.com/api/modifier-un-administrateur/adipisci'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Request      

DELETE api/modifier-un-administrateur/{id}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

id   string   

The ID of the modifier un administrateur. Example: adipisci

Module Beneficiaire

Mise à jour information bénéficiaire

requires authentication

Example request:
curl --request PATCH \
    "https://api.services4aged.com/api/update-beneficiary-information" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: multipart/form-data" \
    --header "Accept: application/json" \
    --form "name=John"\
    --form "last_name=Doe"\
    --form "phone=696661135"\
    --form "country_residence=Cameroun"\
    --form "city_residence=Yaoundé"\
    --form "date_birth=1996-03-11"\
    --form "email=nativemind@google.com"\
    --form "password=Admin@1234"\
    --form "lang=suscipit"\
    --form "photo=@/tmp/phpu1hV9O" \
    --form "file_antecedent_medicaux=@/tmp/phpBjXuvZ" 
const url = new URL(
    "https://api.services4aged.com/api/update-beneficiary-information"
);

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

const body = new FormData();
body.append('name', 'John');
body.append('last_name', 'Doe');
body.append('phone', '696661135');
body.append('country_residence', 'Cameroun');
body.append('city_residence', 'Yaoundé');
body.append('date_birth', '1996-03-11');
body.append('email', 'nativemind@google.com');
body.append('password', 'Admin@1234');
body.append('lang', 'suscipit');
body.append('photo', document.querySelector('input[name="photo"]').files[0]);
body.append('file_antecedent_medicaux', document.querySelector('input[name="file_antecedent_medicaux"]').files[0]);

fetch(url, {
    method: "PATCH",
    headers,
    body,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.services4aged.com/api/update-beneficiary-information';
$response = $client->patch(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'multipart/form-data',
            'Accept' => 'application/json',
        ],
        'multipart' => [
            [
                'name' => 'name',
                'contents' => 'John'
            ],
            [
                'name' => 'last_name',
                'contents' => 'Doe'
            ],
            [
                'name' => 'phone',
                'contents' => '696661135'
            ],
            [
                'name' => 'country_residence',
                'contents' => 'Cameroun'
            ],
            [
                'name' => 'city_residence',
                'contents' => 'Yaoundé'
            ],
            [
                'name' => 'date_birth',
                'contents' => '1996-03-11'
            ],
            [
                'name' => 'email',
                'contents' => 'nativemind@google.com'
            ],
            [
                'name' => 'password',
                'contents' => 'Admin@1234'
            ],
            [
                'name' => 'lang',
                'contents' => 'suscipit'
            ],
            [
                'name' => 'photo',
                'contents' => fopen('/tmp/phpu1hV9O', 'r')
            ],
            [
                'name' => 'file_antecedent_medicaux',
                'contents' => fopen('/tmp/phpBjXuvZ', 'r')
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.services4aged.com/api/update-beneficiary-information'
files = {
  'name': (None, 'John'),
  'last_name': (None, 'Doe'),
  'phone': (None, '696661135'),
  'country_residence': (None, 'Cameroun'),
  'city_residence': (None, 'Yaoundé'),
  'date_birth': (None, '1996-03-11'),
  'email': (None, 'nativemind@google.com'),
  'password': (None, 'Admin@1234'),
  'lang': (None, 'suscipit'),
  'photo': open('/tmp/phpu1hV9O', 'rb'),
  'file_antecedent_medicaux': open('/tmp/phpBjXuvZ', 'rb')}
payload = {
    "name": "John",
    "last_name": "Doe",
    "phone": "696661135",
    "country_residence": "Cameroun",
    "city_residence": "Yaoundé",
    "date_birth": "1996-03-11",
    "email": "nativemind@google.com",
    "password": "Admin@1234",
    "lang": "suscipit"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'multipart/form-data',
  'Accept': 'application/json'
}

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

Request      

PATCH api/update-beneficiary-information

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: multipart/form-data

Accept      

Example: application/json

Body Parameters

name   string  optional  

name of user. Must not be greater than 255 characters. Example: John

beneficiary_id   string  optional  
last_name   string  optional  

name of user. Must not be greater than 255 characters. Example: Doe

phone   string  optional  

phone of user. Must not be greater than 14 characters. Example: 696661135

photo   file  optional  

Must be an image. Must not be greater than 2048 kilobytes. Example: /tmp/phpu1hV9O

file_antecedent_medicaux   file  optional  

Must be a file. Must not be greater than 2048 kilobytes. Example: /tmp/phpBjXuvZ

country_residence   string  optional  

Pays de résidence. Example: Cameroun

city_residence   string  optional  

Ville de résidence. Example: Yaoundé

date_birth   string  optional  

Date de naissance. Must be a valid date. Example: 1996-03-11

email   string  optional  

email of user. Must be a valid email address. Must not be greater than 255 characters. Example: nativemind@google.com

password   string  optional  

password of user. Example: Admin@1234

lang   string  optional  

Example: suscipit

Mise à jour information bénéficiaire

requires authentication

Example request:
curl --request PATCH \
    "https://api.services4aged.com/api/souscripteur-update-beneficiary" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: multipart/form-data" \
    --header "Accept: application/json" \
    --form "name=John"\
    --form "last_name=Doe"\
    --form "phone=696661135"\
    --form "country_residence=Cameroun"\
    --form "city_residence=Yaoundé"\
    --form "date_birth=1996-03-11"\
    --form "email=nativemind@google.com"\
    --form "password=Admin@1234"\
    --form "lang=enim"\
    --form "photo=@/tmp/phpfCw3To" \
    --form "file_antecedent_medicaux=@/tmp/phphaX8CM" 
const url = new URL(
    "https://api.services4aged.com/api/souscripteur-update-beneficiary"
);

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

const body = new FormData();
body.append('name', 'John');
body.append('last_name', 'Doe');
body.append('phone', '696661135');
body.append('country_residence', 'Cameroun');
body.append('city_residence', 'Yaoundé');
body.append('date_birth', '1996-03-11');
body.append('email', 'nativemind@google.com');
body.append('password', 'Admin@1234');
body.append('lang', 'enim');
body.append('photo', document.querySelector('input[name="photo"]').files[0]);
body.append('file_antecedent_medicaux', document.querySelector('input[name="file_antecedent_medicaux"]').files[0]);

fetch(url, {
    method: "PATCH",
    headers,
    body,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.services4aged.com/api/souscripteur-update-beneficiary';
$response = $client->patch(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'multipart/form-data',
            'Accept' => 'application/json',
        ],
        'multipart' => [
            [
                'name' => 'name',
                'contents' => 'John'
            ],
            [
                'name' => 'last_name',
                'contents' => 'Doe'
            ],
            [
                'name' => 'phone',
                'contents' => '696661135'
            ],
            [
                'name' => 'country_residence',
                'contents' => 'Cameroun'
            ],
            [
                'name' => 'city_residence',
                'contents' => 'Yaoundé'
            ],
            [
                'name' => 'date_birth',
                'contents' => '1996-03-11'
            ],
            [
                'name' => 'email',
                'contents' => 'nativemind@google.com'
            ],
            [
                'name' => 'password',
                'contents' => 'Admin@1234'
            ],
            [
                'name' => 'lang',
                'contents' => 'enim'
            ],
            [
                'name' => 'photo',
                'contents' => fopen('/tmp/phpfCw3To', 'r')
            ],
            [
                'name' => 'file_antecedent_medicaux',
                'contents' => fopen('/tmp/phphaX8CM', 'r')
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.services4aged.com/api/souscripteur-update-beneficiary'
files = {
  'name': (None, 'John'),
  'last_name': (None, 'Doe'),
  'phone': (None, '696661135'),
  'country_residence': (None, 'Cameroun'),
  'city_residence': (None, 'Yaoundé'),
  'date_birth': (None, '1996-03-11'),
  'email': (None, 'nativemind@google.com'),
  'password': (None, 'Admin@1234'),
  'lang': (None, 'enim'),
  'photo': open('/tmp/phpfCw3To', 'rb'),
  'file_antecedent_medicaux': open('/tmp/phphaX8CM', 'rb')}
payload = {
    "name": "John",
    "last_name": "Doe",
    "phone": "696661135",
    "country_residence": "Cameroun",
    "city_residence": "Yaoundé",
    "date_birth": "1996-03-11",
    "email": "nativemind@google.com",
    "password": "Admin@1234",
    "lang": "enim"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'multipart/form-data',
  'Accept': 'application/json'
}

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

Request      

PATCH api/souscripteur-update-beneficiary

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: multipart/form-data

Accept      

Example: application/json

Body Parameters

name   string  optional  

name of user. Must not be greater than 255 characters. Example: John

beneficiary_id   string  optional  
last_name   string  optional  

name of user. Must not be greater than 255 characters. Example: Doe

phone   string  optional  

phone of user. Must not be greater than 14 characters. Example: 696661135

photo   file  optional  

Must be an image. Must not be greater than 2048 kilobytes. Example: /tmp/phpfCw3To

file_antecedent_medicaux   file  optional  

Must be a file. Must not be greater than 2048 kilobytes. Example: /tmp/phphaX8CM

country_residence   string  optional  

Pays de résidence. Example: Cameroun

city_residence   string  optional  

Ville de résidence. Example: Yaoundé

date_birth   string  optional  

Date de naissance. Must be a valid date. Example: 1996-03-11

email   string  optional  

email of user. Must be a valid email address. Must not be greater than 255 characters. Example: nativemind@google.com

password   string  optional  

password of user. Example: Admin@1234

lang   string  optional  

Example: enim

Module Note

Note prestataire

requires authentication

Example request:
curl --request POST \
    "https://api.services4aged.com/api/note-prestataire" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"external_id\": 2,
    \"type\": \"prestaire\",
    \"tag\": \"un commentaire\",
    \"rate\": 6
}"

const url = new URL(
    "https://api.services4aged.com/api/note-prestataire"
);

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

let body = {
    "external_id": 2,
    "type": "prestaire",
    "tag": "un commentaire",
    "rate": 6
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.services4aged.com/api/note-prestataire';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'external_id' => 2,
            'type' => 'prestaire',
            'tag' => 'un commentaire',
            'rate' => 6,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.services4aged.com/api/note-prestataire'
payload = {
    "external_id": 2,
    "type": "prestaire",
    "tag": "un commentaire",
    "rate": 6
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Request      

POST api/note-prestataire

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

external_id   string   

Id de la ressource a noté (prestation ou prestataire). Example: 2

type   string   

le type de ressource a noté. Example: prestaire

Must be one of:
  • prestation
  • prestataire
tag   string   

Commentaire sur la ressource noté. Example: un commentaire

rate   string   

Une note comprise entre 1-10. Must be at least 1 character. Must not be greater than 10 characters. Example: 6

Note prestation

requires authentication

Example request:
curl --request POST \
    "https://api.services4aged.com/api/note-prestation" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"external_id\": 2,
    \"type\": \"prestaire\",
    \"tag\": \"un commentaire\",
    \"rate\": 6
}"

const url = new URL(
    "https://api.services4aged.com/api/note-prestation"
);

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

let body = {
    "external_id": 2,
    "type": "prestaire",
    "tag": "un commentaire",
    "rate": 6
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.services4aged.com/api/note-prestation';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'external_id' => 2,
            'type' => 'prestaire',
            'tag' => 'un commentaire',
            'rate' => 6,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.services4aged.com/api/note-prestation'
payload = {
    "external_id": 2,
    "type": "prestaire",
    "tag": "un commentaire",
    "rate": 6
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Request      

POST api/note-prestation

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

external_id   string   

Id de la ressource a noté (prestation ou prestataire). Example: 2

type   string   

le type de ressource a noté. Example: prestaire

Must be one of:
  • prestation
  • prestataire
tag   string   

Commentaire sur la ressource noté. Example: un commentaire

rate   string   

Une note comprise entre 1-10. Must be at least 1 character. Must not be greater than 10 characters. Example: 6

GET api/note-exist/{prestation_id}

requires authentication

Example request:
curl --request GET \
    --get "https://api.services4aged.com/api/note-exist/autem" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.services4aged.com/api/note-exist/autem"
);

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

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

url = 'https://api.services4aged.com/api/note-exist/autem'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  '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/note-exist/{prestation_id}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

prestation_id   string   

The ID of the prestation. Example: autem

Evenement

Récupère tous les événements de l'utilisateur authentifié.

requires authentication

Example request:
curl --request GET \
    --get "https://api.services4aged.com/api/events" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.services4aged.com/api/events"
);

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

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

url = 'https://api.services4aged.com/api/events'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  '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/events

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Récupère les détails d'un événement spécifique.

requires authentication

Example request:
curl --request GET \
    --get "https://api.services4aged.com/api/events/mollitia" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.services4aged.com/api/events/mollitia"
);

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

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

url = 'https://api.services4aged.com/api/events/mollitia'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  '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/events/{id}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

id   string   

The ID of the event. Example: mollitia

Crée un nouvel événement avec les détails fournis.

requires authentication

Example request:
curl --request POST \
    "https://api.services4aged.com/api/events" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"title\": \"adwu\",
    \"description\": \"Magni voluptas suscipit eos hic aut.\",
    \"start_date\": \"2023-10-06T13:45:20\",
    \"end_date\": \"2049-06-22\"
}"

const url = new URL(
    "https://api.services4aged.com/api/events"
);

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

let body = {
    "title": "adwu",
    "description": "Magni voluptas suscipit eos hic aut.",
    "start_date": "2023-10-06T13:45:20",
    "end_date": "2049-06-22"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.services4aged.com/api/events';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'title' => 'adwu',
            'description' => 'Magni voluptas suscipit eos hic aut.',
            'start_date' => '2023-10-06T13:45:20',
            'end_date' => '2049-06-22',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.services4aged.com/api/events'
payload = {
    "title": "adwu",
    "description": "Magni voluptas suscipit eos hic aut.",
    "start_date": "2023-10-06T13:45:20",
    "end_date": "2049-06-22"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Request      

POST api/events

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

title   string   

Must not be greater than 255 characters. Example: adwu

description   string  optional  

Example: Magni voluptas suscipit eos hic aut.

start_date   string   

Must be a valid date. Example: 2023-10-06T13:45:20

end_date   string   

Must be a valid date. Must be a date after or equal to start_date. Example: 2049-06-22

Met à jour les détails d'un événement spécifique.

requires authentication

Example request:
curl --request PUT \
    "https://api.services4aged.com/api/events/est" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"title\": \"tkifzv\",
    \"description\": \"Modi ut voluptas illo neque voluptas pariatur recusandae consequatur.\",
    \"start_date\": \"2023-10-06T13:45:20\",
    \"end_date\": \"2038-06-19\"
}"

const url = new URL(
    "https://api.services4aged.com/api/events/est"
);

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

let body = {
    "title": "tkifzv",
    "description": "Modi ut voluptas illo neque voluptas pariatur recusandae consequatur.",
    "start_date": "2023-10-06T13:45:20",
    "end_date": "2038-06-19"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.services4aged.com/api/events/est';
$response = $client->put(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'title' => 'tkifzv',
            'description' => 'Modi ut voluptas illo neque voluptas pariatur recusandae consequatur.',
            'start_date' => '2023-10-06T13:45:20',
            'end_date' => '2038-06-19',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.services4aged.com/api/events/est'
payload = {
    "title": "tkifzv",
    "description": "Modi ut voluptas illo neque voluptas pariatur recusandae consequatur.",
    "start_date": "2023-10-06T13:45:20",
    "end_date": "2038-06-19"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Request      

PUT api/events/{id}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

id   string   

The ID of the event. Example: est

Body Parameters

title   string  optional  

Must not be greater than 255 characters. Example: tkifzv

description   string  optional  

Example: Modi ut voluptas illo neque voluptas pariatur recusandae consequatur.

start_date   string   

Must be a valid date. Example: 2023-10-06T13:45:20

end_date   string   

Must be a valid date. Must be a date after or equal to start_date. Example: 2038-06-19

Supprime un événement spécifique.

requires authentication

Example request:
curl --request DELETE \
    "https://api.services4aged.com/api/events/ut" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.services4aged.com/api/events/ut"
);

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

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.services4aged.com/api/events/ut';
$response = $client->delete(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.services4aged.com/api/events/ut'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Request      

DELETE api/events/{id}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

id   string   

The ID of the event. Example: ut

Endpoints

GET api/payments-methods

requires authentication

Example request:
curl --request GET \
    --get "https://api.services4aged.com/api/payments-methods" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.services4aged.com/api/payments-methods"
);

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

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

url = 'https://api.services4aged.com/api/payments-methods'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200):

Show headers 
cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 60
x-ratelimit-remaining: 57
vary: Origin
 

{
    "status": true,
    "data": {
        "payments": [
            {
                "id": 1,
                "name": "Orange Money",
                "created_at": "2023-09-05T23:20:48.000000Z",
                "updated_at": "2023-09-05T23:20:48.000000Z"
            },
            {
                "id": 2,
                "name": "Mtn Money",
                "created_at": "2023-09-05T23:20:48.000000Z",
                "updated_at": "2023-09-05T23:20:48.000000Z"
            },
            {
                "id": 3,
                "name": "Yoome Monney",
                "created_at": "2023-09-05T23:20:48.000000Z",
                "updated_at": "2023-09-05T23:20:48.000000Z"
            },
            {
                "id": 4,
                "name": "Cash",
                "created_at": "2023-09-05T23:20:48.000000Z",
                "updated_at": "2023-09-05T23:20:48.000000Z"
            },
            {
                "id": 5,
                "name": "Carte de credit",
                "created_at": "2023-09-05T23:20:48.000000Z",
                "updated_at": "2023-09-05T23:20:48.000000Z"
            }
        ]
    },
    "message": "Payment charged successfully"
}

Request      

GET api/payments-methods

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Module Profession

All professions

requires authentication

Example request:
curl --request GET \
    --get "https://api.services4aged.com/api/professions" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.services4aged.com/api/professions"
);

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

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

url = 'https://api.services4aged.com/api/professions'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200):

Show headers 
cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 60
x-ratelimit-remaining: 56
vary: Origin
 

{
    "status": true,
    "data": {
        "professions": [
            {
                "id": 1,
                "name": "Medecin",
                "created_at": "2023-09-05T23:20:48.000000Z",
                "updated_at": "2023-09-05T23:20:48.000000Z"
            },
            {
                "id": 2,
                "name": "Aide soignant",
                "created_at": "2023-09-05T23:20:48.000000Z",
                "updated_at": "2023-09-05T23:20:48.000000Z"
            },
            {
                "id": 3,
                "name": "Infirmier",
                "created_at": "2023-09-05T23:20:48.000000Z",
                "updated_at": "2023-09-05T23:20:48.000000Z"
            },
            {
                "id": 4,
                "name": "Agent d'entretien",
                "created_at": "2023-09-05T23:20:48.000000Z",
                "updated_at": "2023-09-05T23:20:48.000000Z"
            },
            {
                "id": 5,
                "name": "Auxilliaire de vie",
                "created_at": "2023-09-28T16:45:05.000000Z",
                "updated_at": "2023-09-28T16:45:05.000000Z"
            },
            {
                "id": 6,
                "name": "Coursier",
                "created_at": "2023-09-28T16:45:05.000000Z",
                "updated_at": "2023-09-28T16:45:05.000000Z"
            },
            {
                "id": 7,
                "name": "Assistant social",
                "created_at": "2023-09-28T16:45:58.000000Z",
                "updated_at": "2023-09-28T16:45:58.000000Z"
            }
        ]
    },
    "message": "Professions charged successfully"
}

Request      

GET api/professions

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Module category Prestation

Categories Prestation

requires authentication

Example request:
curl --request GET \
    --get "https://api.services4aged.com/api/categories-prestations" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.services4aged.com/api/categories-prestations"
);

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

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

url = 'https://api.services4aged.com/api/categories-prestations'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200):

Show headers 
cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 60
x-ratelimit-remaining: 55
vary: Origin
 

{
    "status": true,
    "data": {
        "categories": [
            {
                "id": 1,
                "name": "Santé",
                "created_at": "2023-09-05T23:20:48.000000Z",
                "updated_at": "2023-09-05T23:20:48.000000Z"
            },
            {
                "id": 2,
                "name": "Ménage",
                "created_at": "2023-09-05T23:20:48.000000Z",
                "updated_at": "2023-09-05T23:20:48.000000Z"
            },
            {
                "id": 3,
                "name": "Loisir",
                "created_at": "2023-09-05T23:20:48.000000Z",
                "updated_at": "2023-09-05T23:20:48.000000Z"
            },
            {
                "id": 4,
                "name": "Auxilliaire",
                "created_at": "2023-09-05T23:20:48.000000Z",
                "updated_at": "2023-09-05T23:20:48.000000Z"
            }
        ]
    },
    "message": "Categories Prestation charged successfully"
}

Request      

GET api/categories-prestations

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Report

Get one report

requires authentication

Example request:
curl --request GET \
    --get "https://api.services4aged.com/api/get-one-report/facere" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.services4aged.com/api/get-one-report/facere"
);

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

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

url = 'https://api.services4aged.com/api/get-one-report/facere'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  '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/get-one-report/{id}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

id   string   

The ID of the get one report. Example: facere

Get unvalidated report

requires authentication

Example request:
curl --request GET \
    --get "https://api.services4aged.com/api/get-unvalidated-report" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.services4aged.com/api/get-unvalidated-report"
);

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

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

url = 'https://api.services4aged.com/api/get-unvalidated-report'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  '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/get-unvalidated-report

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Get validated report

requires authentication

Example request:
curl --request GET \
    --get "https://api.services4aged.com/api/get-validated-report" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.services4aged.com/api/get-validated-report"
);

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

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

url = 'https://api.services4aged.com/api/get-validated-report'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  '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/get-validated-report

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Validated report

requires authentication

Example request:
curl --request PATCH \
    "https://api.services4aged.com/api/validated-report/ab" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.services4aged.com/api/validated-report/ab"
);

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

fetch(url, {
    method: "PATCH",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.services4aged.com/api/validated-report/ab';
$response = $client->patch(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.services4aged.com/api/validated-report/ab'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Request      

PATCH api/validated-report/{id}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

id   string   

The ID of the validated report. Example: ab

Unvalidated report

requires authentication

Example request:
curl --request PATCH \
    "https://api.services4aged.com/api/unvalidated-report/aliquid" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.services4aged.com/api/unvalidated-report/aliquid"
);

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

fetch(url, {
    method: "PATCH",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.services4aged.com/api/unvalidated-report/aliquid';
$response = $client->patch(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.services4aged.com/api/unvalidated-report/aliquid'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Request      

PATCH api/unvalidated-report/{id}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

id   string   

The ID of the unvalidated report. Example: aliquid

Get all report of my prestation

requires authentication

Example request:
curl --request GET \
    --get "https://api.services4aged.com/api/get-patient-report/explicabo" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.services4aged.com/api/get-patient-report/explicabo"
);

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

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

url = 'https://api.services4aged.com/api/get-patient-report/explicabo'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  '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/get-patient-report/{patient_id}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

patient_id   string   

The ID of the patient. Example: explicabo

Get report of my patient

requires authentication

Example request:
curl --request GET \
    --get "https://api.services4aged.com/api/get-report-of-my-patient/quis" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.services4aged.com/api/get-report-of-my-patient/quis"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.services4aged.com/api/get-report-of-my-patient/quis';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.services4aged.com/api/get-report-of-my-patient/quis'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  '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/get-report-of-my-patient/{patient_id}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

patient_id   string   

The ID of the patient. Example: quis

Store report

requires authentication

Example request:
curl --request POST \
    "https://api.services4aged.com/api/store-rapport-prestation" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"patient_id\": 1,
    \"prestation_id\": 3,
    \"motifs\": \"Douleurs abdominales\",
    \"history_antecedents\": \"Hypertension artérielle\",
    \"enquete_system\": \"Cardiovasculaire, respiratoire\",
    \"imc\": 25.5,
    \"pa\": 120,
    \"fc\": 75,
    \"sao2\": 97,
    \"temperature\": 37.5,
    \"diagnostic_differentiels\": \"Gastro-entérite, ulcère gastroduodénal\",
    \"file\": \"rapport_medical.pdf\",
    \"prise_en_charge\": \"Médication\",
    \"enquete_nutritionnelle\": \"Régime équilibré\",
    \"enquete_hygiene\": \"Bonne hygiène corporelle\"
}"

const url = new URL(
    "https://api.services4aged.com/api/store-rapport-prestation"
);

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

let body = {
    "patient_id": 1,
    "prestation_id": 3,
    "motifs": "Douleurs abdominales",
    "history_antecedents": "Hypertension artérielle",
    "enquete_system": "Cardiovasculaire, respiratoire",
    "imc": 25.5,
    "pa": 120,
    "fc": 75,
    "sao2": 97,
    "temperature": 37.5,
    "diagnostic_differentiels": "Gastro-entérite, ulcère gastroduodénal",
    "file": "rapport_medical.pdf",
    "prise_en_charge": "Médication",
    "enquete_nutritionnelle": "Régime équilibré",
    "enquete_hygiene": "Bonne hygiène corporelle"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://api.services4aged.com/api/store-rapport-prestation';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'patient_id' => 1,
            'prestation_id' => 3,
            'motifs' => 'Douleurs abdominales',
            'history_antecedents' => 'Hypertension artérielle',
            'enquete_system' => 'Cardiovasculaire, respiratoire',
            'imc' => 25.5,
            'pa' => 120.0,
            'fc' => 75.0,
            'sao2' => 97.0,
            'temperature' => 37.5,
            'diagnostic_differentiels' => 'Gastro-entérite, ulcère gastroduodénal',
            'file' => 'rapport_medical.pdf',
            'prise_en_charge' => 'Médication',
            'enquete_nutritionnelle' => 'Régime équilibré',
            'enquete_hygiene' => 'Bonne hygiène corporelle',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.services4aged.com/api/store-rapport-prestation'
payload = {
    "patient_id": 1,
    "prestation_id": 3,
    "motifs": "Douleurs abdominales",
    "history_antecedents": "Hypertension artérielle",
    "enquete_system": "Cardiovasculaire, respiratoire",
    "imc": 25.5,
    "pa": 120,
    "fc": 75,
    "sao2": 97,
    "temperature": 37.5,
    "diagnostic_differentiels": "Gastro-entérite, ulcère gastroduodénal",
    "file": "rapport_medical.pdf",
    "prise_en_charge": "Médication",
    "enquete_nutritionnelle": "Régime équilibré",
    "enquete_hygiene": "Bonne hygiène corporelle"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Request      

POST api/store-rapport-prestation

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

patient_id   string   

ID du patient. Example: 1

prestation_id   string   

ID de la prestation. Example: 3

motifs   string   

Motifs de la consultation. Example: Douleurs abdominales

history_antecedents   string   

Antécédents médicaux. Example: Hypertension artérielle

enquete_system   string   

Enquête systémique. Example: Cardiovasculaire, respiratoire

imc   number   

Indice de masse corporelle. Example: 25.5

pa   number   

Pression artérielle. Example: 120

fc   number   

Fréquence cardiaque. Example: 75

sao2   number   

Saturation en oxygène. Example: 97

temperature   number   

Température corporelle. Example: 37.5

diagnostic_differentiels   string   

Diagnostics différentiels. Example: Gastro-entérite, ulcère gastroduodénal

file   string  optional  

Fichier (rapport médical, etc.). Must not be greater than 10240 characters. Example: rapport_medical.pdf

prise_en_charge   string   

Prise en charge. Example: Médication

enquete_nutritionnelle   string   

Enquête nutritionnelle. Example: Régime équilibré

enquete_hygiene   string   

Enquête hygiène. Example: Bonne hygiène corporelle

Get beneficiaury report

requires authentication

Example request:
curl --request GET \
    --get "https://api.services4aged.com/api/get-beneficiairy-report" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.services4aged.com/api/get-beneficiairy-report"
);

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

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

url = 'https://api.services4aged.com/api/get-beneficiairy-report'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  '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/get-beneficiairy-report

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json