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.

Endpoints

GET api/payments-methods

requires authentication

Example request:
curl --request GET \
    --get "https://staging-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://staging-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://staging-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://staging-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 (403):

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

{
    "status": false,
    "errors": [],
    "message": "Access denied contact the administrator"
}

Request      

GET api/payments-methods

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

GET api/confirm-cash-payment/{reference}

requires authentication

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

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://staging-api.services4aged.com/api/confirm-cash-payment/quaerat';
$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://staging-api.services4aged.com/api/confirm-cash-payment/quaerat'
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/confirm-cash-payment/{reference}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

reference   string   

Example: quaerat

GET api/cancel-cash-payment/{reference}

requires authentication

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

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://staging-api.services4aged.com/api/cancel-cash-payment/voluptas';
$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://staging-api.services4aged.com/api/cancel-cash-payment/voluptas'
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/cancel-cash-payment/{reference}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

reference   string   

Example: voluptas

GET api/details-cash-transaction/{reference}

requires authentication

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

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://staging-api.services4aged.com/api/details-cash-transaction/ipsam';
$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://staging-api.services4aged.com/api/details-cash-transaction/ipsam'
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-cash-transaction/{reference}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

reference   string   

Example: ipsam

GET api/get-cash-payment

requires authentication

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

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://staging-api.services4aged.com/api/get-cash-payment';
$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://staging-api.services4aged.com/api/get-cash-payment'
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-cash-payment

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

GET api/list-refund-admin

requires authentication

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

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://staging-api.services4aged.com/api/list-refund-admin';
$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://staging-api.services4aged.com/api/list-refund-admin'
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-refund-admin

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

POST api/approve-refund/{id}

requires authentication

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

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://staging-api.services4aged.com/api/approve-refund/et';
$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://staging-api.services4aged.com/api/approve-refund/et'
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/approve-refund/{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 approve refund. Example: et

POST api/reject-refund/{id}

requires authentication

Example request:
curl --request POST \
    "https://staging-api.services4aged.com/api/reject-refund/dolores" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"rejection_reason\": \"dolor\"
}"

const url = new URL(
    "https://staging-api.services4aged.com/api/reject-refund/dolores"
);

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

let body = {
    "rejection_reason": "dolor"
};

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

url = 'https://staging-api.services4aged.com/api/reject-refund/dolores'
payload = {
    "rejection_reason": "dolor"
}
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/reject-refund/{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 reject refund. Example: dolores

Body Parameters

rejection_reason   string   

Example: dolor

GET api/ask-payment/{prestation_id}

requires authentication

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

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://staging-api.services4aged.com/api/ask-payment/et';
$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://staging-api.services4aged.com/api/ask-payment/et'
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/ask-payment/{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: et

GET api/list-refund-souscripteur

requires authentication

Example request:
curl --request GET \
    --get "https://staging-api.services4aged.com/api/list-refund-souscripteur" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://staging-api.services4aged.com/api/list-refund-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://staging-api.services4aged.com/api/list-refund-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://staging-api.services4aged.com/api/list-refund-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-refund-souscripteur

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

POST api/pay-as-cash

requires authentication

Example request:
curl --request POST \
    "https://staging-api.services4aged.com/api/pay-as-cash" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: multipart/form-data" \
    --header "Accept: application/json" \
    --form "total_amount=non"\
    --form "description=Deleniti omnis ut fugit a et."\
    --form "prestation_id=ullam"\
    --form "photo=@/tmp/phpexsBSu" 
const url = new URL(
    "https://staging-api.services4aged.com/api/pay-as-cash"
);

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

const body = new FormData();
body.append('total_amount', 'non');
body.append('description', 'Deleniti omnis ut fugit a et.');
body.append('prestation_id', 'ullam');
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://staging-api.services4aged.com/api/pay-as-cash';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'multipart/form-data',
            'Accept' => 'application/json',
        ],
        'multipart' => [
            [
                'name' => 'total_amount',
                'contents' => 'non'
            ],
            [
                'name' => 'description',
                'contents' => 'Deleniti omnis ut fugit a et.'
            ],
            [
                'name' => 'prestation_id',
                'contents' => 'ullam'
            ],
            [
                'name' => 'photo',
                'contents' => fopen('/tmp/phpexsBSu', 'r')
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://staging-api.services4aged.com/api/pay-as-cash'
files = {
  'total_amount': (None, 'non'),
  'description': (None, 'Deleniti omnis ut fugit a et.'),
  'prestation_id': (None, 'ullam'),
  'photo': open('/tmp/phpexsBSu', 'rb')}
payload = {
    "total_amount": "non",
    "description": "Deleniti omnis ut fugit a et.",
    "prestation_id": "ullam"
}
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/pay-as-cash

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: multipart/form-data

Accept      

Example: application/json

Body Parameters

total_amount   string   

Example: non

description   string   

Example: Deleniti omnis ut fugit a et.

prestation_id   string   

Example: ullam

photo   file   

Le champ value doit être une image. Le fichier value ne peut être plus gros que 3072 kilo-octets. Example: /tmp/phpexsBSu

Store a newly created refund request in storage.

requires authentication

Example request:
curl --request POST \
    "https://staging-api.services4aged.com/api/refund-requests" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"reason\": \"molestiae\",
    \"prestation_id\": \"quo\",
    \"amount\": \"id\",
    \"phone\": \"quia\"
}"

const url = new URL(
    "https://staging-api.services4aged.com/api/refund-requests"
);

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

let body = {
    "reason": "molestiae",
    "prestation_id": "quo",
    "amount": "id",
    "phone": "quia"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://staging-api.services4aged.com/api/refund-requests';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'reason' => 'molestiae',
            'prestation_id' => 'quo',
            'amount' => 'id',
            'phone' => 'quia',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://staging-api.services4aged.com/api/refund-requests'
payload = {
    "reason": "molestiae",
    "prestation_id": "quo",
    "amount": "id",
    "phone": "quia"
}
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/refund-requests

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

reason   string   

Example: molestiae

prestation_id   string   

Example: quo

amount   string   

Example: id

phone   string   

Example: quia

Evenement

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

requires authentication

Example request:
curl --request GET \
    --get "https://staging-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://staging-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://staging-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://staging-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://staging-api.services4aged.com/api/events/esse" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://staging-api.services4aged.com/api/events/esse"
);

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://staging-api.services4aged.com/api/events/esse';
$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://staging-api.services4aged.com/api/events/esse'
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: esse

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

requires authentication

Example request:
curl --request POST \
    "https://staging-api.services4aged.com/api/events" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"title\": \"xwnesysonxuvoykybsvgdk\",
    \"description\": \"Omnis esse voluptatem cumque placeat voluptates error.\",
    \"start_date\": \"2024-09-26T17:31:29\",
    \"end_date\": \"2061-02-24\"
}"

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

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

let body = {
    "title": "xwnesysonxuvoykybsvgdk",
    "description": "Omnis esse voluptatem cumque placeat voluptates error.",
    "start_date": "2024-09-26T17:31:29",
    "end_date": "2061-02-24"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://staging-api.services4aged.com/api/events';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'title' => 'xwnesysonxuvoykybsvgdk',
            'description' => 'Omnis esse voluptatem cumque placeat voluptates error.',
            'start_date' => '2024-09-26T17:31:29',
            'end_date' => '2061-02-24',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://staging-api.services4aged.com/api/events'
payload = {
    "title": "xwnesysonxuvoykybsvgdk",
    "description": "Omnis esse voluptatem cumque placeat voluptates error.",
    "start_date": "2024-09-26T17:31:29",
    "end_date": "2061-02-24"
}
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   

Le texte de value ne peut contenir plus de 255 caractères. Example: xwnesysonxuvoykybsvgdk

description   string  optional  

Example: Omnis esse voluptatem cumque placeat voluptates error.

start_date   string   

Le champ value n'est pas une date valide. Example: 2024-09-26T17:31:29

end_date   string   

Le champ value n'est pas une date valide. Le champ value doit être une date après ou égale à start_date. Example: 2061-02-24

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

requires authentication

Example request:
curl --request PUT \
    "https://staging-api.services4aged.com/api/events/in" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"title\": \"nlqcavrlzjmpvznskkewnrwka\",
    \"description\": \"Accusantium facere veniam sunt omnis laborum.\",
    \"start_date\": \"2024-09-26T17:31:29\",
    \"end_date\": \"2031-02-09\"
}"

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

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

let body = {
    "title": "nlqcavrlzjmpvznskkewnrwka",
    "description": "Accusantium facere veniam sunt omnis laborum.",
    "start_date": "2024-09-26T17:31:29",
    "end_date": "2031-02-09"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://staging-api.services4aged.com/api/events/in';
$response = $client->put(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'title' => 'nlqcavrlzjmpvznskkewnrwka',
            'description' => 'Accusantium facere veniam sunt omnis laborum.',
            'start_date' => '2024-09-26T17:31:29',
            'end_date' => '2031-02-09',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://staging-api.services4aged.com/api/events/in'
payload = {
    "title": "nlqcavrlzjmpvznskkewnrwka",
    "description": "Accusantium facere veniam sunt omnis laborum.",
    "start_date": "2024-09-26T17:31:29",
    "end_date": "2031-02-09"
}
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: in

Body Parameters

title   string  optional  

Le texte de value ne peut contenir plus de 255 caractères. Example: nlqcavrlzjmpvznskkewnrwka

description   string  optional  

Example: Accusantium facere veniam sunt omnis laborum.

start_date   string   

Le champ value n'est pas une date valide. Example: 2024-09-26T17:31:29

end_date   string   

Le champ value n'est pas une date valide. Le champ value doit être une date après ou égale à start_date. Example: 2031-02-09

Supprime un événement spécifique.

requires authentication

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

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://staging-api.services4aged.com/api/events/quia';
$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://staging-api.services4aged.com/api/events/quia'
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: quia

Module Authentification

POST api/logout

requires authentication

Example request:
curl --request POST \
    "https://staging-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://staging-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://staging-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://staging-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://staging-api.services4aged.com/api/login" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"email\": \"jade02@example.org\",
    \"password\": \"3?bk)1JWQe6\\\"a+5\"
}"

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

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

let body = {
    "email": "jade02@example.org",
    "password": "3?bk)1JWQe6\"a+5"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://staging-api.services4aged.com/api/login';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'email' => 'jade02@example.org',
            'password' => '3?bk)1JWQe6"a+5',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://staging-api.services4aged.com/api/login'
payload = {
    "email": "jade02@example.org",
    "password": "3?bk)1JWQe6\"a+5"
}
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   

Le champ value doit être une adresse email valide. Example: jade02@example.org

password   string   

Example: 3?bk)1JWQe6"a+5

POST api/forgot-password

Example request:
curl --request POST \
    "https://staging-api.services4aged.com/api/forgot-password" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"email\": \"parker.suzanne@example.org\",
    \"device\": \"eaque\"
}"

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

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

let body = {
    "email": "parker.suzanne@example.org",
    "device": "eaque"
};

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

url = 'https://staging-api.services4aged.com/api/forgot-password'
payload = {
    "email": "parker.suzanne@example.org",
    "device": "eaque"
}
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   

Le champ value doit être une adresse email valide. Example: parker.suzanne@example.org

device   string   

Example: eaque

POST api/reset-password

Example request:
curl --request POST \
    "https://staging-api.services4aged.com/api/reset-password" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"device\": \"mobile\",
    \"email\": \"dayna.rogahn@example.org\",
    \"password\": \"provident\"
}"

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

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

let body = {
    "device": "mobile",
    "email": "dayna.rogahn@example.org",
    "password": "provident"
};

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

url = 'https://staging-api.services4aged.com/api/reset-password'
payload = {
    "device": "mobile",
    "email": "dayna.rogahn@example.org",
    "password": "provident"
}
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: mobile

Must be one of:
  • mobile
  • web
email   string   

Le champ value doit être une adresse email valide. Example: dayna.rogahn@example.org

password   string   

Example: provident

POST api/verify-token

requires authentication

Example request:
curl --request POST \
    "https://staging-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://staging-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://staging-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://staging-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/verify-otp-password

requires authentication

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

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

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

let body = {
    "email": "cathy.corkery@example.net",
    "otp": "ex"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://staging-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' => 'cathy.corkery@example.net',
            'otp' => 'ex',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://staging-api.services4aged.com/api/verify-otp-password'
payload = {
    "email": "cathy.corkery@example.net",
    "otp": "ex"
}
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   

Le champ value doit être une adresse email valide. Le texte de value ne peut contenir plus de 255 caractères. Example: cathy.corkery@example.net

otp   string   

Example: ex

Verify email

requires authentication

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

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://staging-api.services4aged.com/api/verify-email/fugiat/unde';
$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://staging-api.services4aged.com/api/verify-email/fugiat/unde'
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: fugiat

hash   string   

Example: unde

Resend email verification

requires authentication

Example request:
curl --request POST \
    "https://staging-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://staging-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://staging-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://staging-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

Module Beneficiaire

Mise à jour information bénéficiaire

requires authentication

Example request:
curl --request PATCH \
    "https://staging-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=consequatur"\
    --form "photo=@/tmp/phpm9V6RN" \
    --form "file_antecedent_medicaux=@/tmp/phpbvUWUW" 
const url = new URL(
    "https://staging-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', 'consequatur');
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://staging-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' => 'consequatur'
            ],
            [
                'name' => 'photo',
                'contents' => fopen('/tmp/phpm9V6RN', 'r')
            ],
            [
                'name' => 'file_antecedent_medicaux',
                'contents' => fopen('/tmp/phpbvUWUW', 'r')
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://staging-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, 'consequatur'),
  'photo': open('/tmp/phpm9V6RN', 'rb'),
  'file_antecedent_medicaux': open('/tmp/phpbvUWUW', '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": "consequatur"
}
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. Le texte de value ne peut contenir plus de 255 caractères. Example: John

beneficiary_id   string  optional  
last_name   string  optional  

name of user. Le texte de value ne peut contenir plus de 255 caractères. Example: Doe

phone   string  optional  

phone of user. Le texte de value ne peut contenir plus de 14 caractères. Example: 696661135

photo   file  optional  

Le champ value doit être une image. Le fichier value ne peut être plus gros que 2048 kilo-octets. Example: /tmp/phpm9V6RN

file_antecedent_medicaux   file  optional  

Must be a file. Le fichier value ne peut être plus gros que 2048 kilo-octets. Example: /tmp/phpbvUWUW

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. Le champ value n'est pas une date valide. Example: 1996-03-11

email   string  optional  

email of user. Le champ value doit être une adresse email valide. Le texte de value ne peut contenir plus de 255 caractères. Example: nativemind@google.com

password   string  optional  

password of user. Example: Admin@1234

lang   string  optional  

Example: consequatur

Mise à jour information bénéficiaire

requires authentication

Example request:
curl --request PATCH \
    "https://staging-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=dolore"\
    --form "photo=@/tmp/phpgmfEwO" \
    --form "file_antecedent_medicaux=@/tmp/phpKPPWQJ" 
const url = new URL(
    "https://staging-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', 'dolore');
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://staging-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' => 'dolore'
            ],
            [
                'name' => 'photo',
                'contents' => fopen('/tmp/phpgmfEwO', 'r')
            ],
            [
                'name' => 'file_antecedent_medicaux',
                'contents' => fopen('/tmp/phpKPPWQJ', 'r')
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://staging-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, 'dolore'),
  'photo': open('/tmp/phpgmfEwO', 'rb'),
  'file_antecedent_medicaux': open('/tmp/phpKPPWQJ', '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": "dolore"
}
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. Le texte de value ne peut contenir plus de 255 caractères. Example: John

beneficiary_id   string  optional  
last_name   string  optional  

name of user. Le texte de value ne peut contenir plus de 255 caractères. Example: Doe

phone   string  optional  

phone of user. Le texte de value ne peut contenir plus de 14 caractères. Example: 696661135

photo   file  optional  

Le champ value doit être une image. Le fichier value ne peut être plus gros que 2048 kilo-octets. Example: /tmp/phpgmfEwO

file_antecedent_medicaux   file  optional  

Must be a file. Le fichier value ne peut être plus gros que 2048 kilo-octets. Example: /tmp/phpKPPWQJ

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. Le champ value n'est pas une date valide. Example: 1996-03-11

email   string  optional  

email of user. Le champ value doit être une adresse email valide. Le texte de value ne peut contenir plus de 255 caractères. Example: nativemind@google.com

password   string  optional  

password of user. Example: Admin@1234

lang   string  optional  

Example: dolore

Module Note

Note prestataire

requires authentication

Example request:
curl --request POST \
    "https://staging-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,
    \"prestation_id\": 2,
    \"type\": \"prestaire\",
    \"tag\": \"un commentaire\",
    \"rate\": 6
}"

const url = new URL(
    "https://staging-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,
    "prestation_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://staging-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,
            'prestation_id' => 2,
            'type' => 'prestaire',
            'tag' => 'un commentaire',
            'rate' => 6,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://staging-api.services4aged.com/api/note-prestataire'
payload = {
    "external_id": 2,
    "prestation_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

prestation_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. Le texte du champ value doit contenir au moins 1 caractères. Le texte de value ne peut contenir plus de 10 caractères. Example: 6

Note prestation

requires authentication

Example request:
curl --request POST \
    "https://staging-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,
    \"prestation_id\": 2,
    \"type\": \"prestaire\",
    \"tag\": \"un commentaire\",
    \"rate\": 6
}"

const url = new URL(
    "https://staging-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,
    "prestation_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://staging-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,
            'prestation_id' => 2,
            'type' => 'prestaire',
            'tag' => 'un commentaire',
            'rate' => 6,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://staging-api.services4aged.com/api/note-prestation'
payload = {
    "external_id": 2,
    "prestation_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

prestation_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. Le texte du champ value doit contenir au moins 1 caractères. Le texte de value ne peut contenir plus de 10 caractères. Example: 6

GET api/note-exist/{prestataire_id}/{prestation_id}

requires authentication

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

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://staging-api.services4aged.com/api/note-exist/saepe/libero';
$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://staging-api.services4aged.com/api/note-exist/saepe/libero'
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/{prestataire_id}/{prestation_id}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

prestataire_id   string   

The ID of the prestataire. Example: saepe

prestation_id   string   

The ID of the prestation. Example: libero

Module Partenaire

Inscription d'un partenaire

requires authentication

Example request:
curl --request POST \
    "https://staging-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=fr"\
    --form "accept_term_condition=1"\
    --form "email=nativemind@google.com"\
    --form "password=Admin@1234"\
    --form "password_confirmation=Admin@1234"\
    --form "photo=@/tmp/phpRttt2L" 
const url = new URL(
    "https://staging-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', 'fr');
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://staging-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' => 'fr'
            ],
            [
                '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/phpRttt2L', 'r')
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://staging-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, 'fr'),
  'accept_term_condition': (None, '1'),
  'email': (None, 'nativemind@google.com'),
  'password': (None, 'Admin@1234'),
  'password_confirmation': (None, 'Admin@1234'),
  'photo': open('/tmp/phpRttt2L', 'rb')}
payload = {
    "name": "John",
    "last_name": "Doe",
    "phone": "696661135",
    "country_residence": "Cameroun",
    "city_residence": "Yaoundé",
    "date_birth": "1996-03-11",
    "lang": "fr",
    "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/phpRttt2L

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: fr

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 Prestataire

store prestataire

requires authentication

Example request:
curl --request POST \
    "https://staging-api.services4aged.com/api/create-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 "country_residence=Cameroun"\
    --form "city_residence=Yaoundé"\
    --form "date_birth=1996-03-11"\
    --form "accept_term_condition=1"\
    --form "email=nativemind@google.com"\
    --form "password=Admin@1234"\
    --form "password_confirmation=Admin@1234"\
    --form "professional_experience=3 years"\
    --form "shool_level=O level"\
    --form "specific_skill=manager"\
    --form "speciality=3"\
    --form "cni_number=3216586158"\
    --form "category_prestataire_id=2"\
    --form "profession_id=3"\
    --form "payment_method_id=5"\
    --form "image=@/tmp/phpA4rjuK" 
const url = new URL(
    "https://staging-api.services4aged.com/api/create-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('country_residence', 'Cameroun');
body.append('city_residence', 'Yaoundé');
body.append('date_birth', '1996-03-11');
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('professional_experience', '3 years');
body.append('shool_level', 'O level');
body.append('specific_skill', 'manager');
body.append('speciality', '3');
body.append('cni_number', '3216586158');
body.append('category_prestataire_id', '2');
body.append('profession_id', '3');
body.append('payment_method_id', '5');
body.append('image', document.querySelector('input[name="image"]').files[0]);

fetch(url, {
    method: "POST",
    headers,
    body,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://staging-api.services4aged.com/api/create-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' => 'country_residence',
                'contents' => 'Cameroun'
            ],
            [
                'name' => 'city_residence',
                'contents' => 'Yaoundé'
            ],
            [
                'name' => 'date_birth',
                'contents' => '1996-03-11'
            ],
            [
                'name' => 'accept_term_condition',
                'contents' => '1'
            ],
            [
                'name' => 'email',
                'contents' => 'nativemind@google.com'
            ],
            [
                'name' => 'password',
                'contents' => 'Admin@1234'
            ],
            [
                'name' => 'password_confirmation',
                'contents' => 'Admin@1234'
            ],
            [
                'name' => 'professional_experience',
                'contents' => '3 years'
            ],
            [
                'name' => 'shool_level',
                'contents' => 'O level'
            ],
            [
                'name' => 'specific_skill',
                'contents' => 'manager'
            ],
            [
                'name' => 'speciality',
                'contents' => '3'
            ],
            [
                'name' => 'cni_number',
                'contents' => '3216586158'
            ],
            [
                'name' => 'category_prestataire_id',
                'contents' => '2'
            ],
            [
                'name' => 'profession_id',
                'contents' => '3'
            ],
            [
                'name' => 'payment_method_id',
                'contents' => '5'
            ],
            [
                'name' => 'image',
                'contents' => fopen('/tmp/phpA4rjuK', 'r')
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://staging-api.services4aged.com/api/create-prestataire'
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'),
  'accept_term_condition': (None, '1'),
  'email': (None, 'nativemind@google.com'),
  'password': (None, 'Admin@1234'),
  'password_confirmation': (None, 'Admin@1234'),
  'professional_experience': (None, '3 years'),
  'shool_level': (None, 'O level'),
  'specific_skill': (None, 'manager'),
  'speciality': (None, '3'),
  'cni_number': (None, '3216586158'),
  'category_prestataire_id': (None, '2'),
  'profession_id': (None, '3'),
  'payment_method_id': (None, '5'),
  'image': open('/tmp/phpA4rjuK', 'rb')}
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': 'multipart/form-data',
  'Accept': 'application/json'
}

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

Request      

POST api/create-prestataire

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

image   file  optional  

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

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   

Accept or deny. 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

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   string   

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

phone_payment   string  optional  

show prestataire

requires authentication

Example request:
curl --request GET \
    --get "https://staging-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://staging-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://staging-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://staging-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://staging-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=iusto"\
    --form "country_residence=Cameroun"\
    --form "city_residence=Yaoundé"\
    --form "date_birth=1996-03-11"\
    --form "accept_term_condition=1"\
    --form "professional_experience=officiis"\
    --form "specific_skill=non"\
    --form "cni_number=iusto"\
    --form "category_prestataire_id=365.16"\
    --form "profession_id=2580969.4510293"\
    --form "phone_payment=3216586158"\
    --form "photo=@/tmp/phpPzji7r" 
const url = new URL(
    "https://staging-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', 'iusto');
body.append('country_residence', 'Cameroun');
body.append('city_residence', 'Yaoundé');
body.append('date_birth', '1996-03-11');
body.append('accept_term_condition', '1');
body.append('professional_experience', 'officiis');
body.append('specific_skill', 'non');
body.append('cni_number', 'iusto');
body.append('category_prestataire_id', '365.16');
body.append('profession_id', '2580969.4510293');
body.append('phone_payment', '3216586158');
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://staging-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' => 'iusto'
            ],
            [
                'name' => 'country_residence',
                'contents' => 'Cameroun'
            ],
            [
                'name' => 'city_residence',
                'contents' => 'Yaoundé'
            ],
            [
                'name' => 'date_birth',
                'contents' => '1996-03-11'
            ],
            [
                'name' => 'accept_term_condition',
                'contents' => '1'
            ],
            [
                'name' => 'professional_experience',
                'contents' => 'officiis'
            ],
            [
                'name' => 'specific_skill',
                'contents' => 'non'
            ],
            [
                'name' => 'cni_number',
                'contents' => 'iusto'
            ],
            [
                'name' => 'category_prestataire_id',
                'contents' => '365.16'
            ],
            [
                'name' => 'profession_id',
                'contents' => '2580969.4510293'
            ],
            [
                'name' => 'phone_payment',
                'contents' => '3216586158'
            ],
            [
                'name' => 'photo',
                'contents' => fopen('/tmp/phpPzji7r', 'r')
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://staging-api.services4aged.com/api/update-prestataire'
files = {
  'name': (None, 'John'),
  'last_name': (None, 'Doe'),
  'phone': (None, '696661135'),
  'lang': (None, 'iusto'),
  'country_residence': (None, 'Cameroun'),
  'city_residence': (None, 'Yaoundé'),
  'date_birth': (None, '1996-03-11'),
  'accept_term_condition': (None, '1'),
  'professional_experience': (None, 'officiis'),
  'specific_skill': (None, 'non'),
  'cni_number': (None, 'iusto'),
  'category_prestataire_id': (None, '365.16'),
  'profession_id': (None, '2580969.4510293'),
  'phone_payment': (None, '3216586158'),
  'photo': open('/tmp/phpPzji7r', 'rb')}
payload = {
    "name": "John",
    "last_name": "Doe",
    "phone": "696661135",
    "lang": "iusto",
    "country_residence": "Cameroun",
    "city_residence": "Yaoundé",
    "date_birth": "1996-03-11",
    "accept_term_condition": true,
    "professional_experience": "officiis",
    "specific_skill": "non",
    "cni_number": "iusto",
    "category_prestataire_id": 365.16,
    "profession_id": 2580969.45102934,
    "phone_payment": "3216586158"
}
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. Le texte de value ne peut contenir plus de 255 caractères. Example: John

last_name   string  optional  

name of user. Le texte de value ne peut contenir plus de 255 caractères. Example: Doe

phone   string  optional  

phone of user. Le texte de value ne peut contenir plus de 14 caractères. Example: 696661135

lang   string  optional  

Example: iusto

photo   file  optional  

Le champ value doit être une image. Le fichier value ne peut être plus gros que 2048 kilo-octets. Example: /tmp/phpPzji7r

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. Le champ value n'est pas une date valide. Example: 1996-03-11

accept_term_condition   boolean   

Example: true

professional_experience   string  optional  

Example: officiis

shool_level   string  optional  
specific_skill   string  optional  

Example: non

speciality   string  optional  
cni_number   string  optional  

Example: iusto

category_prestataire_id   number  optional  

Example: 365.16

profession_id   number  optional  

Example: 2580969.4510293

phone_payment   string  optional  

Enter your phone payment. Example: 3216586158

Module Profession

All professions

requires authentication

Example request:
curl --request GET \
    --get "https://staging-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://staging-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://staging-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://staging-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 (403):

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

{
    "status": false,
    "errors": [],
    "message": "Access denied contact the administrator"
}

Request      

GET api/professions

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Module Souscripteur

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

requires authentication

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

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://staging-api.services4aged.com/api/get-beneficiary-details/neque';
$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://staging-api.services4aged.com/api/get-beneficiary-details/neque'
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: neque

Creer un souscripteur

requires authentication

Example request:
curl --request POST \
    "https://staging-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=fr"\
    --form "accept_term_condition=1"\
    --form "email=nativemind@google.com"\
    --form "password=Admin@1234"\
    --form "password_confirmation=Admin@1234"\
    --form "photo=@/tmp/phpwY5vvq" 
const url = new URL(
    "https://staging-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', 'fr');
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://staging-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' => 'fr'
            ],
            [
                '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/phpwY5vvq', 'r')
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://staging-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, 'fr'),
  'accept_term_condition': (None, '1'),
  'email': (None, 'nativemind@google.com'),
  'password': (None, 'Admin@1234'),
  'password_confirmation': (None, 'Admin@1234'),
  'photo': open('/tmp/phpwY5vvq', 'rb')}
payload = {
    "name": "John",
    "last_name": "Doe",
    "phone": "696661135",
    "country_residence": "Cameroun",
    "city_residence": "Yaoundé",
    "date_birth": "1996-03-11",
    "lang": "fr",
    "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/phpwY5vvq

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: fr

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

Créer un beneficiaire

requires authentication

Example request:
curl --request POST \
    "https://staging-api.services4aged.com/api/create-beneficiary" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: multipart/form-data" \
    --header "Accept: application/json" \
    --form "name=x"\
    --form "last_name=eptv"\
    --form "phone=adxjwx"\
    --form "country_residence=facilis"\
    --form "city_residence=aut"\
    --form "date_birth=2024-09-26T17:31:28"\
    --form "lang=en"\
    --form "accept_term_condition=1"\
    --form "email=tjacobs@example.com"\
    --form "password=perspiciatis"\
    --form "password_confirmation=doloribus"\
    --form "name_contact=et"\
    --form "phone_contact=enim"\
    --form "parenter=minima"\
    --form "photo=@/tmp/phpUS3WpV" \
    --form "file_antecedent_medicaux=@/tmp/phpjxiOmX" 
const url = new URL(
    "https://staging-api.services4aged.com/api/create-beneficiary"
);

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

const body = new FormData();
body.append('name', 'x');
body.append('last_name', 'eptv');
body.append('phone', 'adxjwx');
body.append('country_residence', 'facilis');
body.append('city_residence', 'aut');
body.append('date_birth', '2024-09-26T17:31:28');
body.append('lang', 'en');
body.append('accept_term_condition', '1');
body.append('email', 'tjacobs@example.com');
body.append('password', 'perspiciatis');
body.append('password_confirmation', 'doloribus');
body.append('name_contact', 'et');
body.append('phone_contact', 'enim');
body.append('parenter', 'minima');
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: "POST",
    headers,
    body,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://staging-api.services4aged.com/api/create-beneficiary';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'multipart/form-data',
            'Accept' => 'application/json',
        ],
        'multipart' => [
            [
                'name' => 'name',
                'contents' => 'x'
            ],
            [
                'name' => 'last_name',
                'contents' => 'eptv'
            ],
            [
                'name' => 'phone',
                'contents' => 'adxjwx'
            ],
            [
                'name' => 'country_residence',
                'contents' => 'facilis'
            ],
            [
                'name' => 'city_residence',
                'contents' => 'aut'
            ],
            [
                'name' => 'date_birth',
                'contents' => '2024-09-26T17:31:28'
            ],
            [
                'name' => 'lang',
                'contents' => 'en'
            ],
            [
                'name' => 'accept_term_condition',
                'contents' => '1'
            ],
            [
                'name' => 'email',
                'contents' => 'tjacobs@example.com'
            ],
            [
                'name' => 'password',
                'contents' => 'perspiciatis'
            ],
            [
                'name' => 'password_confirmation',
                'contents' => 'doloribus'
            ],
            [
                'name' => 'name_contact',
                'contents' => 'et'
            ],
            [
                'name' => 'phone_contact',
                'contents' => 'enim'
            ],
            [
                'name' => 'parenter',
                'contents' => 'minima'
            ],
            [
                'name' => 'photo',
                'contents' => fopen('/tmp/phpUS3WpV', 'r')
            ],
            [
                'name' => 'file_antecedent_medicaux',
                'contents' => fopen('/tmp/phpjxiOmX', 'r')
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://staging-api.services4aged.com/api/create-beneficiary'
files = {
  'name': (None, 'x'),
  'last_name': (None, 'eptv'),
  'phone': (None, 'adxjwx'),
  'country_residence': (None, 'facilis'),
  'city_residence': (None, 'aut'),
  'date_birth': (None, '2024-09-26T17:31:28'),
  'lang': (None, 'en'),
  'accept_term_condition': (None, '1'),
  'email': (None, 'tjacobs@example.com'),
  'password': (None, 'perspiciatis'),
  'password_confirmation': (None, 'doloribus'),
  'name_contact': (None, 'et'),
  'phone_contact': (None, 'enim'),
  'parenter': (None, 'minima'),
  'photo': open('/tmp/phpUS3WpV', 'rb'),
  'file_antecedent_medicaux': open('/tmp/phpjxiOmX', 'rb')}
payload = {
    "name": "x",
    "last_name": "eptv",
    "phone": "adxjwx",
    "country_residence": "facilis",
    "city_residence": "aut",
    "date_birth": "2024-09-26T17:31:28",
    "lang": "en",
    "accept_term_condition": true,
    "email": "tjacobs@example.com",
    "password": "perspiciatis",
    "password_confirmation": "doloribus",
    "name_contact": "et",
    "phone_contact": "enim",
    "parenter": "minima"
}
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-beneficiary

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: multipart/form-data

Accept      

Example: application/json

Body Parameters

name   string   

Le texte de value ne peut contenir plus de 255 caractères. Example: x

last_name   string   

Le texte de value ne peut contenir plus de 255 caractères. Example: eptv

phone   string   

Le texte de value ne peut contenir plus de 14 caractères. Example: adxjwx

photo   file  optional  

Le champ value doit être une image. Le fichier value ne peut être plus gros que 2048 kilo-octets. Example: /tmp/phpUS3WpV

file_antecedent_medicaux   file  optional  

Must be a file. Le fichier value ne peut être plus gros que 4048 kilo-octets. Example: /tmp/phpjxiOmX

country_residence   string   

Example: facilis

city_residence   string   

Example: aut

date_birth   string   

Le champ value n'est pas une date valide. Example: 2024-09-26T17:31:28

lang   string   

Example: en

Must be one of:
  • en
  • fr
accept_term_condition   boolean   

Must be accepted. Example: true

email   string   

Le champ value doit être une adresse email valide. Le texte de value ne peut contenir plus de 255 caractères. Example: tjacobs@example.com

password   string   

Example: perspiciatis

password_confirmation   string   

Example: doloribus

name_contact   string   

Example: et

phone_contact   string   

Example: enim

parenter   string   

Example: minima

Liste beneficiaire souscripteur

requires authentication

Example request:
curl --request GET \
    --get "https://staging-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://staging-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://staging-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://staging-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://staging-api.services4aged.com/api/delete-beneficiary/quod" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://staging-api.services4aged.com/api/delete-beneficiary/quod"
);

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://staging-api.services4aged.com/api/delete-beneficiary/quod';
$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://staging-api.services4aged.com/api/delete-beneficiary/quod'
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: quod

Metre à jour un souscripteur

requires authentication

Example request:
curl --request PATCH \
    "https://staging-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=dolorem"\
    --form "photo=@/tmp/phph22dmA" \
    --form "file_antecedent_medicaux=@/tmp/phpYDzP1e" 
const url = new URL(
    "https://staging-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', 'dolorem');
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://staging-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' => 'dolorem'
            ],
            [
                'name' => 'photo',
                'contents' => fopen('/tmp/phph22dmA', 'r')
            ],
            [
                'name' => 'file_antecedent_medicaux',
                'contents' => fopen('/tmp/phpYDzP1e', 'r')
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://staging-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, 'dolorem'),
  'photo': open('/tmp/phph22dmA', 'rb'),
  'file_antecedent_medicaux': open('/tmp/phpYDzP1e', '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": "dolorem"
}
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. Le texte de value ne peut contenir plus de 255 caractères. Example: John

beneficiary_id   string  optional  
last_name   string  optional  

name of user. Le texte de value ne peut contenir plus de 255 caractères. Example: Doe

phone   string  optional  

phone of user. Le texte de value ne peut contenir plus de 14 caractères. Example: 696661135

photo   file  optional  

Le champ value doit être une image. Le fichier value ne peut être plus gros que 2048 kilo-octets. Example: /tmp/phph22dmA

file_antecedent_medicaux   file  optional  

Must be a file. Le fichier value ne peut être plus gros que 2048 kilo-octets. Example: /tmp/phpYDzP1e

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. Le champ value n'est pas une date valide. Example: 1996-03-11

email   string  optional  

email of user. Le champ value doit être une adresse email valide. Le texte de value ne peut contenir plus de 255 caractères. Example: nativemind@google.com

password   string  optional  

password of user. Example: Admin@1234

lang   string  optional  

Example: dolorem

POST api/restrict-souscripteur/{souscripteur_id}

requires authentication

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

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://staging-api.services4aged.com/api/restrict-souscripteur/itaque';
$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://staging-api.services4aged.com/api/restrict-souscripteur/itaque'
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/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: itaque

GET api/get-my-souscripteur

requires authentication

Example request:
curl --request GET \
    --get "https://staging-api.services4aged.com/api/get-my-souscripteur" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://staging-api.services4aged.com/api/get-my-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://staging-api.services4aged.com/api/get-my-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://staging-api.services4aged.com/api/get-my-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/get-my-souscripteur

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Remove restrict souscripteur

requires authentication

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

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://staging-api.services4aged.com/api/remove-restriction/non';
$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://staging-api.services4aged.com/api/remove-restriction/non'
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/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: non

Module administrateur

Liste des prestataires inactif

requires authentication

Example request:
curl --request GET \
    --get "https://staging-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://staging-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://staging-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://staging-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

Liste des prestataires inactif

requires authentication

Example request:
curl --request POST \
    "https://staging-api.services4aged.com/api/get-unactived-prestataire-filter" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"start_date\": \"2024-09-26T17:31:28\",
    \"end_date\": \"2058-05-18\"
}"

const url = new URL(
    "https://staging-api.services4aged.com/api/get-unactived-prestataire-filter"
);

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

let body = {
    "start_date": "2024-09-26T17:31:28",
    "end_date": "2058-05-18"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://staging-api.services4aged.com/api/get-unactived-prestataire-filter';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'start_date' => '2024-09-26T17:31:28',
            'end_date' => '2058-05-18',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://staging-api.services4aged.com/api/get-unactived-prestataire-filter'
payload = {
    "start_date": "2024-09-26T17:31:28",
    "end_date": "2058-05-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/get-unactived-prestataire-filter

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

start_date   string   

Le champ value n'est pas une date valide. Example: 2024-09-26T17:31:28

end_date   string   

Le champ value n'est pas une date valide. Le champ value doit être une date après ou égale à start_date. Example: 2058-05-18

Activer un prestataire

requires authentication

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

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

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

let body = {
    "prestataire_id": 14
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://staging-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' => 14,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://staging-api.services4aged.com/api/active-prestataire'
payload = {
    "prestataire_id": 14
}
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: 14

Désactiver un prestataire

requires authentication

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

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

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

let body = {
    "prestataire_id": 5
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://staging-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' => 5,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://staging-api.services4aged.com/api/unactive-prestataire'
payload = {
    "prestataire_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/unactive-prestataire

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

prestataire_id   integer   

Example: 5

Delete du prestataire

requires authentication

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

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

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

let body = {
    "prestataire_id": 15
};

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

url = 'https://staging-api.services4aged.com/api/delete-prestataire'
payload = {
    "prestataire_id": 15
}
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/delete-prestataire

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

prestataire_id   integer   

Example: 15

Liste des prestataires

requires authentication

Example request:
curl --request GET \
    --get "https://staging-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://staging-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://staging-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://staging-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 des souscripteurs

requires authentication

Example request:
curl --request GET \
    --get "https://staging-api.services4aged.com/api/get-all-souscripteur" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://staging-api.services4aged.com/api/get-all-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://staging-api.services4aged.com/api/get-all-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://staging-api.services4aged.com/api/get-all-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/get-all-souscripteur

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Liste des bénéficiaires

requires authentication

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

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://staging-api.services4aged.com/api/get-all-beneficiaries';
$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://staging-api.services4aged.com/api/get-all-beneficiaries'
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-beneficiaries

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Details d'un souscripteur

requires authentication

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

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://staging-api.services4aged.com/api/get-details-souscripteur/qui';
$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://staging-api.services4aged.com/api/get-details-souscripteur/qui'
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-details-souscripteur/{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 details souscripteur. Example: qui

Details d'un beneficiaire

requires authentication

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

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://staging-api.services4aged.com/api/get-details-beneficiary/est';
$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://staging-api.services4aged.com/api/get-details-beneficiary/est'
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-details-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 get details beneficiary. Example: est

Detail du prestataire

requires authentication

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

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://staging-api.services4aged.com/api/details-prestataire/ut';
$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://staging-api.services4aged.com/api/details-prestataire/ut'
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-prestataire/{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 prestataire. Example: ut

POST api/beneficiaires-filter

requires authentication

Example request:
curl --request POST \
    "https://staging-api.services4aged.com/api/beneficiaires-filter" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"start_date\": \"2024-09-26T17:31:28\",
    \"end_date\": \"2049-10-31\"
}"

const url = new URL(
    "https://staging-api.services4aged.com/api/beneficiaires-filter"
);

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

let body = {
    "start_date": "2024-09-26T17:31:28",
    "end_date": "2049-10-31"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://staging-api.services4aged.com/api/beneficiaires-filter';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'start_date' => '2024-09-26T17:31:28',
            'end_date' => '2049-10-31',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://staging-api.services4aged.com/api/beneficiaires-filter'
payload = {
    "start_date": "2024-09-26T17:31:28",
    "end_date": "2049-10-31"
}
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/beneficiaires-filter

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

start_date   string   

Le champ value n'est pas une date valide. Example: 2024-09-26T17:31:28

end_date   string   

Le champ value n'est pas une date valide. Le champ value doit être une date après ou égale à start_date. Example: 2049-10-31

POST api/souscripteurs-filter

requires authentication

Example request:
curl --request POST \
    "https://staging-api.services4aged.com/api/souscripteurs-filter" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"start_date\": \"2024-09-26T17:31:28\",
    \"end_date\": \"2074-01-22\"
}"

const url = new URL(
    "https://staging-api.services4aged.com/api/souscripteurs-filter"
);

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

let body = {
    "start_date": "2024-09-26T17:31:28",
    "end_date": "2074-01-22"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://staging-api.services4aged.com/api/souscripteurs-filter';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'start_date' => '2024-09-26T17:31:28',
            'end_date' => '2074-01-22',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://staging-api.services4aged.com/api/souscripteurs-filter'
payload = {
    "start_date": "2024-09-26T17:31:28",
    "end_date": "2074-01-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/souscripteurs-filter

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

start_date   string   

Le champ value n'est pas une date valide. Example: 2024-09-26T17:31:28

end_date   string   

Le champ value n'est pas une date valide. Le champ value doit être une date après ou égale à start_date. Example: 2074-01-22

POST api/prestataires-filter

requires authentication

Example request:
curl --request POST \
    "https://staging-api.services4aged.com/api/prestataires-filter" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"start_date\": \"2024-09-26T17:31:28\",
    \"end_date\": \"2059-12-12\"
}"

const url = new URL(
    "https://staging-api.services4aged.com/api/prestataires-filter"
);

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

let body = {
    "start_date": "2024-09-26T17:31:28",
    "end_date": "2059-12-12"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://staging-api.services4aged.com/api/prestataires-filter';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'start_date' => '2024-09-26T17:31:28',
            'end_date' => '2059-12-12',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://staging-api.services4aged.com/api/prestataires-filter'
payload = {
    "start_date": "2024-09-26T17:31:28",
    "end_date": "2059-12-12"
}
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/prestataires-filter

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

start_date   string   

Le champ value n'est pas une date valide. Example: 2024-09-26T17:31:28

end_date   string   

Le champ value n'est pas une date valide. Le champ value doit être une date après ou égale à start_date. Example: 2059-12-12

Get all Prestation for specific prestation

requires authentication

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

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://staging-api.services4aged.com/api/get-prestataires-for-prestation/libero';
$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://staging-api.services4aged.com/api/get-prestataires-for-prestation/libero'
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-prestataires-for-prestation/{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 prestataires for prestation. Example: libero

Get all Prestation for sollicitation of specific prestation

requires authentication

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

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://staging-api.services4aged.com/api/get-prestataires-for-prestation-sollicitation/ut';
$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://staging-api.services4aged.com/api/get-prestataires-for-prestation-sollicitation/ut'
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-prestataires-for-prestation-sollicitation/{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 prestataires for prestation sollicitation. Example: ut

POST api/sollicitation/{id}

requires authentication

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

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://staging-api.services4aged.com/api/sollicitation/voluptatum';
$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://staging-api.services4aged.com/api/sollicitation/voluptatum'
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/sollicitation/{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 sollicitation. Example: voluptatum

Liste prestation non cloturer

requires authentication

Example request:
curl --request GET \
    --get "https://staging-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://staging-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://staging-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://staging-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://staging-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://staging-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://staging-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://staging-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://staging-api.services4aged.com/api/assign-prestataire" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"prestation_id\": 4,
    \"prestataire_id\": 13
}"

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

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

let body = {
    "prestation_id": 4,
    "prestataire_id": 13
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://staging-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' => 4,
            'prestataire_id' => 13,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://staging-api.services4aged.com/api/assign-prestataire'
payload = {
    "prestation_id": 4,
    "prestataire_id": 13
}
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: 4

prestataire_id   integer   

Example: 13

Module category Prestation

Categories Prestation

requires authentication

Example request:
curl --request GET \
    --get "https://staging-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://staging-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://staging-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://staging-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 (403):

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

{
    "status": false,
    "errors": [],
    "message": "Access denied contact the administrator"
}

Request      

GET api/categories-prestations

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Module package

Details of the package

requires authentication

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

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://staging-api.services4aged.com/api/package-details/cum';
$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://staging-api.services4aged.com/api/package-details/cum'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (403):

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": "Access denied contact the administrator"
}

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: cum

Get all package

requires authentication

Example request:
curl --request GET \
    --get "https://staging-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://staging-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://staging-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://staging-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 (403):

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

{
    "status": false,
    "errors": [],
    "message": "Access denied contact the administrator"
}

Request      

GET api/list-all-package

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Details of the package

requires authentication

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

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://staging-api.services4aged.com/api/get-package-details-souscription';
$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://staging-api.services4aged.com/api/get-package-details-souscription'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (403):

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

{
    "status": false,
    "errors": [],
    "message": "Access denied contact the administrator"
}

Request      

GET api/get-package-details-souscription

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Create package

requires authentication

Example request:
curl --request POST \
    "https://staging-api.services4aged.com/api/create-package" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: multipart/form-data" \
    --header "Accept: application/json" \
    --form "title=Premium"\
    --form "category_prestation_id=2"\
    --form "missions=Guard patient"\
    --form "price=5000"\
    --form "duration=79"\
    --form "type=mensuel"\
    --form "amount_prestataire=71"\
    --form "disabled_at=2053-02-13"\
    --form "photo=@/tmp/phpqc4EPS" 
const url = new URL(
    "https://staging-api.services4aged.com/api/create-package"
);

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

const body = new FormData();
body.append('title', 'Premium');
body.append('category_prestation_id', '2');
body.append('missions', 'Guard patient');
body.append('price', '5000');
body.append('duration', '79');
body.append('type', 'mensuel');
body.append('amount_prestataire', '71');
body.append('disabled_at', '2053-02-13');
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://staging-api.services4aged.com/api/create-package';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'multipart/form-data',
            'Accept' => 'application/json',
        ],
        'multipart' => [
            [
                'name' => 'title',
                'contents' => 'Premium'
            ],
            [
                'name' => 'category_prestation_id',
                'contents' => '2'
            ],
            [
                'name' => 'missions',
                'contents' => 'Guard patient'
            ],
            [
                'name' => 'price',
                'contents' => '5000'
            ],
            [
                'name' => 'duration',
                'contents' => '79'
            ],
            [
                'name' => 'type',
                'contents' => 'mensuel'
            ],
            [
                'name' => 'amount_prestataire',
                'contents' => '71'
            ],
            [
                'name' => 'disabled_at',
                'contents' => '2053-02-13'
            ],
            [
                'name' => 'photo',
                'contents' => fopen('/tmp/phpqc4EPS', 'r')
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://staging-api.services4aged.com/api/create-package'
files = {
  'title': (None, 'Premium'),
  'category_prestation_id': (None, '2'),
  'missions': (None, 'Guard patient'),
  'price': (None, '5000'),
  'duration': (None, '79'),
  'type': (None, 'mensuel'),
  'amount_prestataire': (None, '71'),
  'disabled_at': (None, '2053-02-13'),
  'photo': open('/tmp/phpqc4EPS', 'rb')}
payload = {
    "title": "Premium",
    "category_prestation_id": 2,
    "missions": "Guard patient",
    "price": 5000,
    "duration": 79,
    "type": "mensuel",
    "amount_prestataire": 71,
    "disabled_at": "2053-02-13"
}
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-package

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: multipart/form-data

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. La valeur de value doit être au moins de 0. Example: 5000

duration   integer   

La valeur de value doit être au moins de 0. Example: 79

type   string   

Example: mensuel

Must be one of:
  • hebdomadaire
  • mensuel
photo   file   

Le champ value doit être une image. Le fichier value ne peut être plus gros que 2048 kilo-octets. Example: /tmp/phpqc4EPS

amount_prestataire   integer   

La valeur de value doit être au moins de 0. Example: 71

disabled_at   string  optional  

This field is required when disable_option is at. Le champ value n'est pas une date valide. Le champ value doit être une date postérieure au today. Example: 2053-02-13

Update package

requires authentication

Example request:
curl --request PATCH \
    "https://staging-api.services4aged.com/api/update-package/harum" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: multipart/form-data" \
    --header "Accept: application/json" \
    --form "title=quo"\
    --form "category_prestation_id=9"\
    --form "missions=possimus"\
    --form "price=18"\
    --form "duration=8"\
    --form "type=mensuel"\
    --form "amount_prestataire=20"\
    --form "disabled_at=2030-01-22"\
    --form "photo=@/tmp/phpHc4ffu" 
const url = new URL(
    "https://staging-api.services4aged.com/api/update-package/harum"
);

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

const body = new FormData();
body.append('title', 'quo');
body.append('category_prestation_id', '9');
body.append('missions', 'possimus');
body.append('price', '18');
body.append('duration', '8');
body.append('type', 'mensuel');
body.append('amount_prestataire', '20');
body.append('disabled_at', '2030-01-22');
body.append('photo', document.querySelector('input[name="photo"]').files[0]);

fetch(url, {
    method: "PATCH",
    headers,
    body,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://staging-api.services4aged.com/api/update-package/harum';
$response = $client->patch(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'multipart/form-data',
            'Accept' => 'application/json',
        ],
        'multipart' => [
            [
                'name' => 'title',
                'contents' => 'quo'
            ],
            [
                'name' => 'category_prestation_id',
                'contents' => '9'
            ],
            [
                'name' => 'missions',
                'contents' => 'possimus'
            ],
            [
                'name' => 'price',
                'contents' => '18'
            ],
            [
                'name' => 'duration',
                'contents' => '8'
            ],
            [
                'name' => 'type',
                'contents' => 'mensuel'
            ],
            [
                'name' => 'amount_prestataire',
                'contents' => '20'
            ],
            [
                'name' => 'disabled_at',
                'contents' => '2030-01-22'
            ],
            [
                'name' => 'photo',
                'contents' => fopen('/tmp/phpHc4ffu', 'r')
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://staging-api.services4aged.com/api/update-package/harum'
files = {
  'title': (None, 'quo'),
  'category_prestation_id': (None, '9'),
  'missions': (None, 'possimus'),
  'price': (None, '18'),
  'duration': (None, '8'),
  'type': (None, 'mensuel'),
  'amount_prestataire': (None, '20'),
  'disabled_at': (None, '2030-01-22'),
  'photo': open('/tmp/phpHc4ffu', 'rb')}
payload = {
    "title": "quo",
    "category_prestation_id": 9,
    "missions": "possimus",
    "price": 18,
    "duration": 8,
    "type": "mensuel",
    "amount_prestataire": 20,
    "disabled_at": "2030-01-22"
}
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-package/{id}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: multipart/form-data

Accept      

Example: application/json

URL Parameters

id   string   

The ID of the update package. Example: harum

Body Parameters

title   string  optional  

Example: quo

category_prestation_id   integer   

Example: 9

missions   string  optional  

Example: possimus

price   integer  optional  

Example: 18

duration   integer  optional  

Example: 8

type   string  optional  

Example: mensuel

Must be one of:
  • hebdomadaire
  • mensuel
photo   file  optional  

Le champ value doit être une image. Le fichier value ne peut être plus gros que 2048 kilo-octets. Example: /tmp/phpHc4ffu

amount_prestataire   integer  optional  

Example: 20

disabled_at   string  optional  

Le champ value n'est pas une date valide. Le champ value doit être une date après ou égale à today. Example: 2030-01-22

Delete package

requires authentication

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

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://staging-api.services4aged.com/api/supprimer-un-package/sed';
$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://staging-api.services4aged.com/api/supprimer-un-package/sed'
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/supprimer-un-package/{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 package. Example: sed

POST api/update-amount-prestataire

requires authentication

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

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://staging-api.services4aged.com/api/update-amount-prestataire';
$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://staging-api.services4aged.com/api/update-amount-prestataire'
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/update-amount-prestataire

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Module prestation

Confirmed Prestation by admin.

requires authentication

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

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://staging-api.services4aged.com/api/isConfirmed/et';
$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://staging-api.services4aged.com/api/isConfirmed/et'
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/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: et

listing available prestation by prestataire

requires authentication

Example request:
curl --request GET \
    --get "https://staging-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://staging-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://staging-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://staging-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

Details prestataire prestation

requires authentication

Example request:
curl --request GET \
    --get "https://staging-api.services4aged.com/api/details-mission-prestataire/nihil/quia" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://staging-api.services4aged.com/api/details-mission-prestataire/nihil/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://staging-api.services4aged.com/api/details-mission-prestataire/nihil/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://staging-api.services4aged.com/api/details-mission-prestataire/nihil/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-mission-prestataire/{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 mission prestataire. Example: nihil

patient_id   string   

The ID of the patient. Example: quia

Close Prestation.

requires authentication

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

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

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

let body = {
    "isClosed": false
};

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

url = 'https://staging-api.services4aged.com/api/isClosed/dolor'
payload = {
    "isClosed": 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/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: dolor

Body Parameters

isClosed   boolean   

Example: false

Candidate Prestation.

requires authentication

Example request:
curl --request POST \
    "https://staging-api.services4aged.com/api/isCandidate/iste" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"isDisponible\": \"eos\"
}"

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

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

let body = {
    "isDisponible": "eos"
};

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

url = 'https://staging-api.services4aged.com/api/isCandidate/iste'
payload = {
    "isDisponible": "eos"
}
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: iste

Body Parameters

isDisponible   string   

Example: eos

Cancel Candidate Prestation.

requires authentication

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

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://staging-api.services4aged.com/api/CancelIsCandidate/occaecati';
$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://staging-api.services4aged.com/api/CancelIsCandidate/occaecati'
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/CancelIsCandidate/{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 CancelIsCandidate. Example: occaecati

POST api/update-phone-number

requires authentication

Example request:
curl --request POST \
    "https://staging-api.services4aged.com/api/update-phone-number" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"phone_payment\": \"aut\",
    \"confirm_phone_payment\": \"ufvylcufikdzqmfniujsycaf\",
    \"name_account\": \"mbx\"
}"

const url = new URL(
    "https://staging-api.services4aged.com/api/update-phone-number"
);

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

let body = {
    "phone_payment": "aut",
    "confirm_phone_payment": "ufvylcufikdzqmfniujsycaf",
    "name_account": "mbx"
};

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

url = 'https://staging-api.services4aged.com/api/update-phone-number'
payload = {
    "phone_payment": "aut",
    "confirm_phone_payment": "ufvylcufikdzqmfniujsycaf",
    "name_account": "mbx"
}
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/update-phone-number

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

phone_payment   string   

Example: aut

confirm_phone_payment   string   

The value and phone_payment must match. Le texte de value ne peut contenir plus de 255 caractères. Example: ufvylcufikdzqmfniujsycaf

name_account   string   

Le texte de value ne peut contenir plus de 255 caractères. Example: mbx

Details prestataire prestation

requires authentication

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

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://staging-api.services4aged.com/api/detailsPrestation/quo';
$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://staging-api.services4aged.com/api/detailsPrestation/quo'
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: quo

Details prestataire prestation

requires authentication

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

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://staging-api.services4aged.com/api/details-patient-rapport/in/distinctio';
$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://staging-api.services4aged.com/api/details-patient-rapport/in/distinctio'
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: in

patient_id   string   

The ID of the patient. Example: distinctio

Pending prestataire prestation

requires authentication

Example request:
curl --request GET \
    --get "https://staging-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://staging-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://staging-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://staging-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

Pending prestataire prestation

requires authentication

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

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://staging-api.services4aged.com/api/listPostulationPrestation';
$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://staging-api.services4aged.com/api/listPostulationPrestation'
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/listPostulationPrestation

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Pending prestataire prestation

requires authentication

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

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://staging-api.services4aged.com/api/prestationsYouCanCandidate';
$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://staging-api.services4aged.com/api/prestationsYouCanCandidate'
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/prestationsYouCanCandidate

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://staging-api.services4aged.com/api/searchPrestations/sint" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://staging-api.services4aged.com/api/searchPrestations/sint"
);

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://staging-api.services4aged.com/api/searchPrestations/sint';
$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://staging-api.services4aged.com/api/searchPrestations/sint'
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: sint

Follow prestation

requires authentication

Example request:
curl --request GET \
    --get "https://staging-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://staging-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://staging-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://staging-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://staging-api.services4aged.com/api/isAvailable/labore" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"isAvailable\": true,
    \"isDisponible\": \"autem\"
}"

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

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

let body = {
    "isAvailable": true,
    "isDisponible": "autem"
};

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

url = 'https://staging-api.services4aged.com/api/isAvailable/labore'
payload = {
    "isAvailable": true,
    "isDisponible": "autem"
}
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: labore

Body Parameters

isAvailable   boolean   

Example: true

isDisponible   string   

Example: autem

Choose Prestation.

requires authentication

Example request:
curl --request POST \
    "https://staging-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://staging-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://staging-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://staging-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. Le champ value n'est pas une date valide. Example: 01/07/2023

Listing prestation area nearby

requires authentication

Example request:
curl --request GET \
    --get "https://staging-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://staging-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://staging-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://staging-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

all prestation

requires authentication

Example request:
curl --request GET \
    --get "https://staging-api.services4aged.com/api/all-prestations" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://staging-api.services4aged.com/api/all-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://staging-api.services4aged.com/api/all-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://staging-api.services4aged.com/api/all-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 (401):

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

{
    "message": "Unauthenticated."
}

Request      

GET api/all-prestations

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

all prestation

requires authentication

Example request:
curl --request POST \
    "https://staging-api.services4aged.com/api/all-prestations-filter" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"start_date\": \"2024-09-26T17:31:28\",
    \"end_date\": \"2102-11-23\"
}"

const url = new URL(
    "https://staging-api.services4aged.com/api/all-prestations-filter"
);

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

let body = {
    "start_date": "2024-09-26T17:31:28",
    "end_date": "2102-11-23"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://staging-api.services4aged.com/api/all-prestations-filter';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'start_date' => '2024-09-26T17:31:28',
            'end_date' => '2102-11-23',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://staging-api.services4aged.com/api/all-prestations-filter'
payload = {
    "start_date": "2024-09-26T17:31:28",
    "end_date": "2102-11-23"
}
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/all-prestations-filter

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

start_date   string   

Le champ value n'est pas une date valide. Example: 2024-09-26T17:31:28

end_date   string   

Le champ value n'est pas une date valide. Le champ value doit être une date après ou égale à start_date. Example: 2102-11-23

Prolonger une Prestation.

requires authentication

Example request:
curl --request POST \
    "https://staging-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://staging-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://staging-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://staging-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. Le champ value n'est pas une date valide. Example: 01/07/2023

Souscripteur prestation

requires authentication

Example request:
curl --request GET \
    --get "https://staging-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://staging-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://staging-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://staging-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://staging-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://staging-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://staging-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://staging-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

Choose Prestation.

requires authentication

Example request:
curl --request POST \
    "https://staging-api.services4aged.com/api/update-date-prestation" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"package_duration\": \"quos\",
    \"prestation_id\": \"repudiandae\",
    \"start_date\": \"2024-09-26T17:31:29\"
}"

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

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

let body = {
    "package_duration": "quos",
    "prestation_id": "repudiandae",
    "start_date": "2024-09-26T17:31:29"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://staging-api.services4aged.com/api/update-date-prestation';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'package_duration' => 'quos',
            'prestation_id' => 'repudiandae',
            'start_date' => '2024-09-26T17:31:29',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://staging-api.services4aged.com/api/update-date-prestation'
payload = {
    "package_duration": "quos",
    "prestation_id": "repudiandae",
    "start_date": "2024-09-26T17:31:29"
}
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/update-date-prestation

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

package_duration   string   

Example: quos

prestation_id   string   

Example: repudiandae

start_date   string   

Le champ value n'est pas une date valide. Example: 2024-09-26T17:31:29

POST api/update-souscripteur-phone-number

requires authentication

Example request:
curl --request POST \
    "https://staging-api.services4aged.com/api/update-souscripteur-phone-number" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"phone_payment\": \"quia\",
    \"confirm_phone_payment\": \"njzcesacajbu\",
    \"name_account\": \"gdnpusg\"
}"

const url = new URL(
    "https://staging-api.services4aged.com/api/update-souscripteur-phone-number"
);

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

let body = {
    "phone_payment": "quia",
    "confirm_phone_payment": "njzcesacajbu",
    "name_account": "gdnpusg"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://staging-api.services4aged.com/api/update-souscripteur-phone-number';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'phone_payment' => 'quia',
            'confirm_phone_payment' => 'njzcesacajbu',
            'name_account' => 'gdnpusg',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://staging-api.services4aged.com/api/update-souscripteur-phone-number'
payload = {
    "phone_payment": "quia",
    "confirm_phone_payment": "njzcesacajbu",
    "name_account": "gdnpusg"
}
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/update-souscripteur-phone-number

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

phone_payment   string   

Example: quia

confirm_phone_payment   string   

The value and phone_payment must match. Le texte de value ne peut contenir plus de 255 caractères. Example: njzcesacajbu

name_account   string   

Le texte de value ne peut contenir plus de 255 caractères. Example: gdnpusg

Souscripteur prestation

requires authentication

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

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://staging-api.services4aged.com/api/list-prestation-beneficiaire';
$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://staging-api.services4aged.com/api/list-prestation-beneficiaire'
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-beneficiaire

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Paiement Module

Get transaction status

requires authentication

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

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://staging-api.services4aged.com/api/payment/getTransactionStatus/dolorum';
$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://staging-api.services4aged.com/api/payment/getTransactionStatus/dolorum'
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/payment/getTransactionStatus/{reference}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

reference   string   

Example: dolorum

requires authentication

Example request:
curl --request POST \
    "https://staging-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://staging-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://staging-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://staging-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()

Withdraw OM/MOMO

requires authentication

Example request:
curl --request POST \
    "https://staging-api.services4aged.com/api/withdrawl" \
    --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\",
    \"prestation_id\": 17
}"

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

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",
    "prestation_id": 17
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://staging-api.services4aged.com/api/withdrawl';
$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',
            'prestation_id' => 17,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://staging-api.services4aged.com/api/withdrawl'
payload = {
    "amount": "5000",
    "to": 237693468041,
    "description": "Payment de la facture No-YH789",
    "prestation_id": 17
}
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/withdrawl

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

prestation_id   integer   

Example: 17

Payment Visa/MasterCard

requires authentication

Example request:
curl --request POST \
    "https://staging-api.services4aged.com/api/stripe-checkout" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"customer_email\": \"schamberger.beulah@example.org\",
    \"product_name\": \"nqtxtqpqtuaotuvrleaun\",
    \"description\": \"Inventore voluptatem id sed quis sed fuga.\",
    \"total_amount\": \"voluptas\",
    \"currency\": \"xaf\",
    \"prestation_id\": \"explicabo\"
}"

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

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

let body = {
    "customer_email": "schamberger.beulah@example.org",
    "product_name": "nqtxtqpqtuaotuvrleaun",
    "description": "Inventore voluptatem id sed quis sed fuga.",
    "total_amount": "voluptas",
    "currency": "xaf",
    "prestation_id": "explicabo"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://staging-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' => 'schamberger.beulah@example.org',
            'product_name' => 'nqtxtqpqtuaotuvrleaun',
            'description' => 'Inventore voluptatem id sed quis sed fuga.',
            'total_amount' => 'voluptas',
            'currency' => 'xaf',
            'prestation_id' => 'explicabo',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://staging-api.services4aged.com/api/stripe-checkout'
payload = {
    "customer_email": "schamberger.beulah@example.org",
    "product_name": "nqtxtqpqtuaotuvrleaun",
    "description": "Inventore voluptatem id sed quis sed fuga.",
    "total_amount": "voluptas",
    "currency": "xaf",
    "prestation_id": "explicabo"
}
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   

Le champ value doit être une adresse email valide. Example: schamberger.beulah@example.org

product_name   string   

Le texte de value ne peut contenir plus de 255 caractères. Example: nqtxtqpqtuaotuvrleaun

description   string   

Le texte de value ne peut contenir plus de 255 caractères. Example: Inventore voluptatem id sed quis sed fuga.

total_amount   string   

Example: voluptas

currency   string   

Example: xaf

Must be one of:
  • usd
  • xaf
  • eur
prestation_id   string   

Example: explicabo

Payment OM/MOMO

requires authentication

Example request:
curl --request POST \
    "https://staging-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\",
    \"prestation_id\": \"earum\"
}"

const url = new URL(
    "https://staging-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",
    "prestation_id": "earum"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://staging-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',
            'prestation_id' => 'earum',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://staging-api.services4aged.com/api/checkout'
payload = {
    "amount": "5000",
    "from": "237693468041",
    "description": "Payment de la facture No-YH789",
    "prestation_id": "earum"
}
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

0   string  optional  
description   string   

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

prestation_id   string   

Example: earum

Report

Get unvalidated report

requires authentication

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

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://staging-api.services4aged.com/api/validated-report/in';
$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://staging-api.services4aged.com/api/validated-report/in'
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: in

Unvalidated report

requires authentication

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

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://staging-api.services4aged.com/api/unvalidated-report/excepturi';
$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://staging-api.services4aged.com/api/unvalidated-report/excepturi'
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: excepturi

Get all report of my prestation

requires authentication

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

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://staging-api.services4aged.com/api/get-patient-report/sapiente';
$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://staging-api.services4aged.com/api/get-patient-report/sapiente'
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: sapiente

Get report of my patient

requires authentication

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

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://staging-api.services4aged.com/api/get-report-of-my-patient/nemo';
$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://staging-api.services4aged.com/api/get-report-of-my-patient/nemo'
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: nemo

Get one report

requires authentication

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

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://staging-api.services4aged.com/api/get-one-report/reprehenderit';
$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://staging-api.services4aged.com/api/get-one-report/reprehenderit'
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: reprehenderit

Get beneficiaury report

requires authentication

Example request:
curl --request GET \
    --get "https://staging-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://staging-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://staging-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://staging-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

Super administrator management

Admin lists

requires authentication

Example request:
curl --request GET \
    --get "https://staging-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://staging-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://staging-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://staging-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://staging-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/phpNYkKve" 
const url = new URL(
    "https://staging-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://staging-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/phpNYkKve', 'r')
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://staging-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/phpNYkKve', '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. Le texte de value ne peut contenir plus de 255 caractères. Example: John

last_name   string   

name of user. Le texte de value ne peut contenir plus de 255 caractères. Example: Doe

phone   string   

phone of user. Le texte de value ne peut contenir plus de 14 caractères. Example: 696661135

photo   file  optional  

Le champ value doit être une image. Le fichier value ne peut être plus gros que 2048 kilo-octets. Example: /tmp/phpNYkKve

country_residence   string   

Pays de résidence. Example: Cameroun

city_residence   string   

Ville de résidence. Example: Yaoundé

date_birth   string   

Date de naissance. Le champ value n'est pas une date valide. 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. Le champ value doit être une adresse email valide. Le texte de value ne peut contenir plus de 255 caractères. 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://staging-api.services4aged.com/api/modifier-un-administrateur/aut" \
    --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://staging-api.services4aged.com/api/modifier-un-administrateur/aut"
);

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://staging-api.services4aged.com/api/modifier-un-administrateur/aut';
$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://staging-api.services4aged.com/api/modifier-un-administrateur/aut'
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/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: aut

Body Parameters

name   string  optional  

name of user. Le texte de value ne peut contenir plus de 255 caractères. Example: John

last_name   string  optional  

name of user. Le texte de value ne peut contenir plus de 255 caractères. Example: Doe

phone   string  optional  

phone of user. Le texte de value ne peut contenir plus de 14 caractères. 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. Le champ value n'est pas une date valide. Example: 1996-03-11

email   string  optional  

email of user. Le champ value doit être une adresse email valide. Le texte de value ne peut contenir plus de 255 caractères. Example: nativemind@google.com

password   string  optional  

password of user. Example: Admin@1234

Delete admin

requires authentication

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

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://staging-api.services4aged.com/api/supprimer-un-administrateur/sint';
$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://staging-api.services4aged.com/api/supprimer-un-administrateur/sint'
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/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: sint

User management

POST api/check-exist-email

requires authentication

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

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

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

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

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://staging-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' => 'bednar.darrion@example.com',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://staging-api.services4aged.com/api/check-exist-email'
payload = {
    "email": "bednar.darrion@example.com"
}
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   

Le champ value doit être une adresse email valide. Example: bednar.darrion@example.com

Display the specified User information.

requires authentication

Example request:
curl --request GET \
    --get "https://staging-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://staging-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://staging-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://staging-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://staging-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://staging-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://staging-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://staging-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://staging-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/php8Brz5E" 
const url = new URL(
    "https://staging-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://staging-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/php8Brz5E', 'r')
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://staging-api.services4aged.com/api/change-avatar'
files = {
  'photo': open('/tmp/php8Brz5E', '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  

Le champ value doit être une image. Le fichier value ne peut être plus gros que 3072 kilo-octets. Example: /tmp/php8Brz5E

POST api/change-lang

requires authentication

Example request:
curl --request POST \
    "https://staging-api.services4aged.com/api/change-lang" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"lang\": \"en\"
}"

const url = new URL(
    "https://staging-api.services4aged.com/api/change-lang"
);

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

let body = {
    "lang": "en"
};

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

url = 'https://staging-api.services4aged.com/api/change-lang'
payload = {
    "lang": "en"
}
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/change-lang

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

lang   string  optional  

Example: en

Must be one of:
  • en
  • fr

Verify email with otp code

requires authentication

Example request:
curl --request POST \
    "https://staging-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://staging-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://staging-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://staging-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 Appoitment

List all appoitments

requires authentication

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

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://staging-api.services4aged.com/api/all-appointment';
$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://staging-api.services4aged.com/api/all-appointment'
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/all-appointment

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Create appoitment

requires authentication

Example request:
curl --request POST \
    "https://staging-api.services4aged.com/api/store-appoitment" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"url\": \"\",
    \"titre\": 2,
    \"label\": \"Consultation à domicile\",
    \"date_debut\": \"09\\/10\\/2023\",
    \"date_fin\": \"09\\/10\\/2023\",
    \"allDay\": true,
    \"patient_id\": 10,
    \"localisation\": \"New localisation\",
    \"description_localisation\": \"Description New localisation\"
}"

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

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

let body = {
    "url": "",
    "titre": 2,
    "label": "Consultation à domicile",
    "date_debut": "09\/10\/2023",
    "date_fin": "09\/10\/2023",
    "allDay": true,
    "patient_id": 10,
    "localisation": "New localisation",
    "description_localisation": "Description New localisation"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://staging-api.services4aged.com/api/store-appoitment';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'url' => '',
            'titre' => 2,
            'label' => 'Consultation à domicile',
            'date_debut' => '09/10/2023',
            'date_fin' => '09/10/2023',
            'allDay' => true,
            'patient_id' => 10,
            'localisation' => 'New localisation',
            'description_localisation' => 'Description New localisation',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://staging-api.services4aged.com/api/store-appoitment'
payload = {
    "url": "",
    "titre": 2,
    "label": "Consultation à domicile",
    "date_debut": "09\/10\/2023",
    "date_fin": "09\/10\/2023",
    "allDay": true,
    "patient_id": 10,
    "localisation": "New localisation",
    "description_localisation": "Description New localisation"
}
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-appoitment

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

url   string  optional  
titre   string   

New events. Example: 2

label   string   

Consultation à domicile. Example: Consultation à domicile

date_debut   string   

Start date. Le champ value n'est pas une date valide. Example: 09/10/2023

date_fin   string   

End date. Le champ value n'est pas une date valide. Example: 09/10/2023

allDay   boolean   

true or false. Example: true

patient_id   string  optional  

Beneficiaire id. Example: 10

localisation   string   

Lieu. Example: New localisation

description_localisation   string  optional  

Description lieu. Example: Description New localisation

Show one appoitment

requires authentication

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

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://staging-api.services4aged.com/api/one-appoitment/fugit';
$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://staging-api.services4aged.com/api/one-appoitment/fugit'
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/one-appoitment/{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 one appoitment. Example: fugit

Update appoitment

requires authentication

Example request:
curl --request PUT \
    "https://staging-api.services4aged.com/api/update-appointment/quo" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"url\": \"\",
    \"titre\": 2,
    \"label\": \"Consultation à domicile\",
    \"date_debut\": \"09\\/10\\/2023\",
    \"date_fin\": \"09\\/10\\/2023\",
    \"allDay\": true,
    \"patient_id\": 10,
    \"localisation\": \"New localisation\",
    \"description_localisation\": \"Description New localisation\"
}"

const url = new URL(
    "https://staging-api.services4aged.com/api/update-appointment/quo"
);

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

let body = {
    "url": "",
    "titre": 2,
    "label": "Consultation à domicile",
    "date_debut": "09\/10\/2023",
    "date_fin": "09\/10\/2023",
    "allDay": true,
    "patient_id": 10,
    "localisation": "New localisation",
    "description_localisation": "Description New localisation"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://staging-api.services4aged.com/api/update-appointment/quo';
$response = $client->put(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'url' => '',
            'titre' => 2,
            'label' => 'Consultation à domicile',
            'date_debut' => '09/10/2023',
            'date_fin' => '09/10/2023',
            'allDay' => true,
            'patient_id' => 10,
            'localisation' => 'New localisation',
            'description_localisation' => 'Description New localisation',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://staging-api.services4aged.com/api/update-appointment/quo'
payload = {
    "url": "",
    "titre": 2,
    "label": "Consultation à domicile",
    "date_debut": "09\/10\/2023",
    "date_fin": "09\/10\/2023",
    "allDay": true,
    "patient_id": 10,
    "localisation": "New localisation",
    "description_localisation": "Description New localisation"
}
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/update-appointment/{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 update appointment. Example: quo

Body Parameters

url   string  optional  
titre   string   

New events. Example: 2

label   string   

Consultation à domicile. Example: Consultation à domicile

date_debut   string   

Start date. Le champ value n'est pas une date valide. Example: 09/10/2023

date_fin   string   

End date. Le champ value n'est pas une date valide. Example: 09/10/2023

allDay   boolean   

true or false. Example: true

patient_id   string  optional  

Beneficiaire id. Example: 10

localisation   string   

Lieu. Example: New localisation

description_localisation   string  optional  

Description lieu. Example: Description New localisation

Destroy one appoitment

requires authentication

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

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://staging-api.services4aged.com/api/delete-appointment/eos';
$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://staging-api.services4aged.com/api/delete-appointment/eos'
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-appointment/{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 appointment. Example: eos