Introduction

Base URL: https://cloud.lektri.co

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

Simple authentication using Bearer tokens

To authenticate requests, include a Authorization header with the value "Bearer {TOKEN}".

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

You can retrieve your token by making a POST request to api/v1/login using your credentails.

Connecting to the API using client credentials

Using OAuth2 via authorization codes is how most developers are familiar with OAuth2. When using authorization codes, a client application will redirect a user to your server where they will either approve or deny the request to issue an access token to the client.

Requesting Tokens

Developers may use their client ID and secret to request an authorization code and access token from your application. First, the consuming application should make a redirect request to your application's /oauth/authorize route like so:

curl -X GET \
  https://cloud.lektri.co/oauth/authorize \
  -d 'grant_type=client_credentials&client_id=CLIENT_ID&redirect_uri=REDIRECT_URI&response_type=code&state=STATE&scope='

Approving the Request

When receiving authorization requests, LEKTRI.CLOUD will display a view to the user allowing them to approve or deny the authorization request. If they approve the request, they will be redirected back to the redirect_uri that was specified by the consuming application.

Converting Authorization Codes to Access Tokens

If the user approves the authorization request, they will be redirected back to the consuming application. The consumer should first verify the state parameter against the value that was stored prior to the redirect. If the state parameter matches then the consumer should issue a POST request to your application to request an access token. The request should include the authorization code that was issued by your application when the user approved the authorization request:

curl -X POST \
  https://cloud.lektri.co/oauth/token \
  -d 'grant_type=authorization_code&client_id=CLIENT_ID&client_secret=CLIENT_SECRET&redirect_uri=REDIRECT_URI&code={ISSUED_CODE}'

This /oauth/token route will return a JSON response containing access_token, refresh_token, and expires_in attributes. The expires_in attribute contains the number of seconds until the access token expires.

Refreshing Tokens

If tokens are about to expire, users will need to refresh their access tokens via the refresh token that was provided to them when the access token was issued:

curl -X POST \
  https://cloud.lektri.co/oauth/token \
  -d 'grant_type=refresh_token&client_id=CLIENT_ID&client_secret=CLIENT_SECRET&refresh_token={REFRESH_TOKEN}&scope='

User management

Login a user.

Example request:

curl --request POST \
    "https://cloud.lektri.co/api/v1/login" \
    --header "Content-Type: application/json" \
    --data "{
    \"email\": \"user@email.com\",
    \"password\": \"passw0rd\"
}"

const url = new URL(
    "https://cloud.lektri.co/api/v1/login"
);

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

let body = {
    "email": "user@email.com",
    "password": "passw0rd"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

import requests
import json

url = 'https://cloud.lektri.co/api/v1/login'
payload = {
    "email": "user@email.com",
    "password": "passw0rd"
}
headers = {
  'Content-Type': 'application/json'
}

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

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://cloud.lektri.co/api/v1/login',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'email' => 'user@email.com',
            'password' => 'passw0rd',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (400):

Show headers

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 2400
x-ratelimit-remaining: 2399
vary: Origin


{
    "success": false,
    "message": "These credentials do not match our records!",
    "reference": "None",
    "data": null
}

Received response:

Request failed with error:

Create a new user

Example request:

curl --request POST \
    "https://cloud.lektri.co/api/v1/register" \
    --header "Content-Type: application/json" \
    --data "{
    \"first_name\": \"Jon\",
    \"last_name\": \"Doe\",
    \"email\": \"user@email.com\",
    \"password\": \"passw0rd\",
    \"timezone\": \"Europe\\/Bucharest\",
    \"language\": \"ro\"
}"

const url = new URL(
    "https://cloud.lektri.co/api/v1/register"
);

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

let body = {
    "first_name": "Jon",
    "last_name": "Doe",
    "email": "user@email.com",
    "password": "passw0rd",
    "timezone": "Europe\/Bucharest",
    "language": "ro"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

import requests
import json

url = 'https://cloud.lektri.co/api/v1/register'
payload = {
    "first_name": "Jon",
    "last_name": "Doe",
    "email": "user@email.com",
    "password": "passw0rd",
    "timezone": "Europe\/Bucharest",
    "language": "ro"
}
headers = {
  'Content-Type': 'application/json'
}

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

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://cloud.lektri.co/api/v1/register',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'first_name' => 'Jon',
            'last_name' => 'Doe',
            'email' => 'user@email.com',
            'password' => 'passw0rd',
            'timezone' => 'Europe/Bucharest',
            'language' => 'ro',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (422):

Show headers

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 2400
x-ratelimit-remaining: 2398
vary: Origin


{
    "success": false,
    "message": "The password confirmation does not match.",
    "reference": "Illuminate\\Validation\\ValidationException",
    "data": null
}

Received response:

Request failed with error:

Request

POST api/v1/register

Headers

Content-Type

Example: application/json

Body Parameters

first_name string

User's first name Example: Jon

last_name string

User's last name Example: Doe

email string

User's email address Example: user@email.com

password string

User's password Example: passw0rd

timezone string

User's timezone Example: Europe/Bucharest

language string

User's language Example: ro

Logout current user.

requires authentication

Example request:

curl --request POST \
    "https://cloud.lektri.co/api/v1/logout" \
    --header "Authorization: Bearer {TOKEN}"

const url = new URL(
    "https://cloud.lektri.co/api/v1/logout"
);

const headers = {
    "Authorization": "Bearer {TOKEN}",
    "Accept": "application/json",
};

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

import requests
import json

url = 'https://cloud.lektri.co/api/v1/logout'
headers = {
  'Authorization': 'Bearer {TOKEN}'
}

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

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://cloud.lektri.co/api/v1/logout',
    [
        'headers' => [
            'Authorization' => 'Bearer {TOKEN}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200):

Show headers

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 2400
x-ratelimit-remaining: 2399
vary: Origin


{
    "success": true,
    "message": "All ok",
    "reference": "None",
    "data": []
}

Received response:

Request failed with error:

Get the current authenticated user.

requires authentication

Example request:

curl --request GET \
    --get "https://cloud.lektri.co/api/v1/user" \
    --header "Authorization: Bearer {TOKEN}"

const url = new URL(
    "https://cloud.lektri.co/api/v1/user"
);

const headers = {
    "Authorization": "Bearer {TOKEN}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

import requests
import json

url = 'https://cloud.lektri.co/api/v1/user'
headers = {
  'Authorization': 'Bearer {TOKEN}'
}

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://cloud.lektri.co/api/v1/user',
    [
        'headers' => [
            'Authorization' => 'Bearer {TOKEN}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200):

Show headers

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 2400
x-ratelimit-remaining: 2398
vary: Origin


{
    "success": true,
    "message": "All ok",
    "reference": "None",
    "data": {
        "id": "a04ac243-d20e-4453-89f3-5e4de4b83338",
        "email": "docs@lektri.co",
        "is_charging": false,
        "active_session": null,
        "name": "Docs User",
        "full_name": "Docs User",
        "first_name": "Docs",
        "last_name": "User",
        "tag": "0GOUwD9Dzl",
        "meta": {
            "timezone": "Europe/Bucharest",
            "language": "en",
            "notifications": {
                "SESSION_START": false,
                "SESSION_END": false,
                "SESSION_STOPPED_LIMIT": false,
                "CHARGER_OFFLINE": false,
                "CHARGER_ONLINE": false,
                "CHARGER_ERROR": true,
                "POWER_SURPLUS": false,
                "session_start": false,
                "session_stop": false,
                "session_event": true
            },
            "notification_channels": {
                "mail": true,
                "push": false
            },
            "notification_settings": {
                "mail": {
                    "SESSION_START": false,
                    "SESSION_END": false,
                    "SESSION_STOPPED_LIMIT": false,
                    "CHARGER_OFFLINE": false,
                    "CHARGER_ONLINE": false,
                    "CHARGER_ERROR": true,
                    "POWER_SURPLUS": false
                },
                "push": {
                    "SESSION_START": false,
                    "SESSION_END": false,
                    "SESSION_STOPPED_LIMIT": false,
                    "CHARGER_OFFLINE": false,
                    "CHARGER_ONLINE": false,
                    "CHARGER_ERROR": true,
                    "POWER_SURPLUS": false
                }
            },
            "features": [],
            "tags": [],
            "defaults": {
                "station": null,
                "chargers": null,
                "meters": null,
                "vehicle": "99037b42-7d49-446e-8403-f7ae6c8c8052"
            }
        },
        "fcm_token": null,
        "photo_url": "https://ui-avatars.com/api/?size=300&color=FFFFFF&background=random&name=Docs+User",
        "tags": [],
        "roles": [
            "Api"
        ]
    }
}

Received response:

Request failed with error:

Updates current user.

requires authentication

Example request:

curl --request PATCH \
    "https://cloud.lektri.co/api/v1/user" \
    --header "Authorization: Bearer {TOKEN}" \
    --header "Content-Type: application/json" \
    --data "{
    \"first_name\": \"qoybzeibzuqrwjczmsbl\",
    \"last_name\": \"nnnrfvepbhqtpe\",
    \"fcm_token\": \"im\",
    \"timezone\": \"Africa\\/Johannesburg\",
    \"language\": \"ej\",
    \"notifications\": {
        \"session_start\": false,
        \"session_stop\": false,
        \"SESSION_START\": true,
        \"SESSION_STOP\": false,
        \"SESSION_STOPPED_LIMIT\": false,
        \"CHARGER_ONLINE\": true,
        \"CHARGER_OFFLINE\": true,
        \"CHARGER_ERROR\": false,
        \"POWER_SURPLUS\": true
    },
    \"notification_channels\": {
        \"mail\": false,
        \"push\": true
    },
    \"notification_settings\": {
        \"mail\": {
            \"SESSION_START\": false,
            \"SESSION_STOP\": false,
            \"SESSION_STOPPED_LIMIT\": true,
            \"CHARGER_ONLINE\": true,
            \"CHARGER_OFFLINE\": false,
            \"CHARGER_ERROR\": true,
            \"POWER_SURPLUS\": false
        },
        \"push\": {
            \"SESSION_START\": false,
            \"SESSION_STOP\": true,
            \"SESSION_STOPPED_LIMIT\": true,
            \"CHARGER_ONLINE\": false,
            \"CHARGER_OFFLINE\": false,
            \"CHARGER_ERROR\": true,
            \"POWER_SURPLUS\": false
        }
    },
    \"address\": {
        \"line1\": \"szcgnyhgrcnfefqkiiyjpeep\",
        \"line2\": \"lw\",
        \"city\": \"vlcsfbgh\",
        \"country\": \"giqagowkjdiwqzgsjgw\",
        \"postal_code\": \"uyzsfqyvwanwfunqyj\",
        \"state\": \"zqjhzvztsh\"
    },
    \"defaults\": {
        \"vehicle\": \"621099cc-75c6-39c7-927e-a82013ef1915\",
        \"station\": \"6d1928ae-2ec9-3fe4-a185-565b26336ee8\",
        \"charger\": \"79c34583-2eb8-3da9-9bdc-1e75ffd31727\"
    }
}"

const url = new URL(
    "https://cloud.lektri.co/api/v1/user"
);

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

let body = {
    "first_name": "qoybzeibzuqrwjczmsbl",
    "last_name": "nnnrfvepbhqtpe",
    "fcm_token": "im",
    "timezone": "Africa\/Johannesburg",
    "language": "ej",
    "notifications": {
        "session_start": false,
        "session_stop": false,
        "SESSION_START": true,
        "SESSION_STOP": false,
        "SESSION_STOPPED_LIMIT": false,
        "CHARGER_ONLINE": true,
        "CHARGER_OFFLINE": true,
        "CHARGER_ERROR": false,
        "POWER_SURPLUS": true
    },
    "notification_channels": {
        "mail": false,
        "push": true
    },
    "notification_settings": {
        "mail": {
            "SESSION_START": false,
            "SESSION_STOP": false,
            "SESSION_STOPPED_LIMIT": true,
            "CHARGER_ONLINE": true,
            "CHARGER_OFFLINE": false,
            "CHARGER_ERROR": true,
            "POWER_SURPLUS": false
        },
        "push": {
            "SESSION_START": false,
            "SESSION_STOP": true,
            "SESSION_STOPPED_LIMIT": true,
            "CHARGER_ONLINE": false,
            "CHARGER_OFFLINE": false,
            "CHARGER_ERROR": true,
            "POWER_SURPLUS": false
        }
    },
    "address": {
        "line1": "szcgnyhgrcnfefqkiiyjpeep",
        "line2": "lw",
        "city": "vlcsfbgh",
        "country": "giqagowkjdiwqzgsjgw",
        "postal_code": "uyzsfqyvwanwfunqyj",
        "state": "zqjhzvztsh"
    },
    "defaults": {
        "vehicle": "621099cc-75c6-39c7-927e-a82013ef1915",
        "station": "6d1928ae-2ec9-3fe4-a185-565b26336ee8",
        "charger": "79c34583-2eb8-3da9-9bdc-1e75ffd31727"
    }
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

import requests
import json

url = 'https://cloud.lektri.co/api/v1/user'
payload = {
    "first_name": "qoybzeibzuqrwjczmsbl",
    "last_name": "nnnrfvepbhqtpe",
    "fcm_token": "im",
    "timezone": "Africa\/Johannesburg",
    "language": "ej",
    "notifications": {
        "session_start": false,
        "session_stop": false,
        "SESSION_START": true,
        "SESSION_STOP": false,
        "SESSION_STOPPED_LIMIT": false,
        "CHARGER_ONLINE": true,
        "CHARGER_OFFLINE": true,
        "CHARGER_ERROR": false,
        "POWER_SURPLUS": true
    },
    "notification_channels": {
        "mail": false,
        "push": true
    },
    "notification_settings": {
        "mail": {
            "SESSION_START": false,
            "SESSION_STOP": false,
            "SESSION_STOPPED_LIMIT": true,
            "CHARGER_ONLINE": true,
            "CHARGER_OFFLINE": false,
            "CHARGER_ERROR": true,
            "POWER_SURPLUS": false
        },
        "push": {
            "SESSION_START": false,
            "SESSION_STOP": true,
            "SESSION_STOPPED_LIMIT": true,
            "CHARGER_ONLINE": false,
            "CHARGER_OFFLINE": false,
            "CHARGER_ERROR": true,
            "POWER_SURPLUS": false
        }
    },
    "address": {
        "line1": "szcgnyhgrcnfefqkiiyjpeep",
        "line2": "lw",
        "city": "vlcsfbgh",
        "country": "giqagowkjdiwqzgsjgw",
        "postal_code": "uyzsfqyvwanwfunqyj",
        "state": "zqjhzvztsh"
    },
    "defaults": {
        "vehicle": "621099cc-75c6-39c7-927e-a82013ef1915",
        "station": "6d1928ae-2ec9-3fe4-a185-565b26336ee8",
        "charger": "79c34583-2eb8-3da9-9bdc-1e75ffd31727"
    }
}
headers = {
  'Authorization': 'Bearer {TOKEN}',
  'Content-Type': 'application/json'
}

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

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'https://cloud.lektri.co/api/v1/user',
    [
        'headers' => [
            'Authorization' => 'Bearer {TOKEN}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'first_name' => 'qoybzeibzuqrwjczmsbl',
            'last_name' => 'nnnrfvepbhqtpe',
            'fcm_token' => 'im',
            'timezone' => 'Africa/Johannesburg',
            'language' => 'ej',
            'notifications' => [
                'session_start' => false,
                'session_stop' => false,
                'SESSION_START' => true,
                'SESSION_STOP' => false,
                'SESSION_STOPPED_LIMIT' => false,
                'CHARGER_ONLINE' => true,
                'CHARGER_OFFLINE' => true,
                'CHARGER_ERROR' => false,
                'POWER_SURPLUS' => true,
            ],
            'notification_channels' => [
                'mail' => false,
                'push' => true,
            ],
            'notification_settings' => [
                'mail' => [
                    'SESSION_START' => false,
                    'SESSION_STOP' => false,
                    'SESSION_STOPPED_LIMIT' => true,
                    'CHARGER_ONLINE' => true,
                    'CHARGER_OFFLINE' => false,
                    'CHARGER_ERROR' => true,
                    'POWER_SURPLUS' => false,
                ],
                'push' => [
                    'SESSION_START' => false,
                    'SESSION_STOP' => true,
                    'SESSION_STOPPED_LIMIT' => true,
                    'CHARGER_ONLINE' => false,
                    'CHARGER_OFFLINE' => false,
                    'CHARGER_ERROR' => true,
                    'POWER_SURPLUS' => false,
                ],
            ],
            'address' => [
                'line1' => 'szcgnyhgrcnfefqkiiyjpeep',
                'line2' => 'lw',
                'city' => 'vlcsfbgh',
                'country' => 'giqagowkjdiwqzgsjgw',
                'postal_code' => 'uyzsfqyvwanwfunqyj',
                'state' => 'zqjhzvztsh',
            ],
            'defaults' => [
                'vehicle' => '621099cc-75c6-39c7-927e-a82013ef1915',
                'station' => '6d1928ae-2ec9-3fe4-a185-565b26336ee8',
                'charger' => '79c34583-2eb8-3da9-9bdc-1e75ffd31727',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (422):

Show headers

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 2400
x-ratelimit-remaining: 2397
vary: Origin


{
    "success": false,
    "message": "The selected defaults.vehicle is invalid. (and 2 more errors)",
    "reference": "Illuminate\\Validation\\ValidationException",
    "data": null
}

Received response:

Request failed with error:

Request

PATCH api/v1/user

Send feedback.

requires authentication

Example request:

curl --request POST \
    "https://cloud.lektri.co/api/v1/user/feedback" \
    --header "Authorization: Bearer {TOKEN}" \
    --header "Content-Type: application/json" \
    --data "{
    \"feedback\": \"nembilfdeme\",
    \"details\": \"itleruutzg\"
}"

const url = new URL(
    "https://cloud.lektri.co/api/v1/user/feedback"
);

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

let body = {
    "feedback": "nembilfdeme",
    "details": "itleruutzg"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

import requests
import json

url = 'https://cloud.lektri.co/api/v1/user/feedback'
payload = {
    "feedback": "nembilfdeme",
    "details": "itleruutzg"
}
headers = {
  'Authorization': 'Bearer {TOKEN}',
  'Content-Type': 'application/json'
}

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

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://cloud.lektri.co/api/v1/user/feedback',
    [
        'headers' => [
            'Authorization' => 'Bearer {TOKEN}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'feedback' => 'nembilfdeme',
            'details' => 'itleruutzg',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200):

Show headers

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 2400
x-ratelimit-remaining: 2396
vary: Origin


{
    "success": true,
    "message": "Feedback sent successfully!",
    "reference": "None",
    "data": []
}

Received response:

Request failed with error:

Request

POST api/v1/user/feedback

Headers

Authorization

Example: Bearer {TOKEN}

Content-Type

Example: application/json

Body Parameters

feedback string

Must not be greater than 1000 characters. Example: nembilfdeme

details string optional

Must not be greater than 1000 characters. Example: itleruutzg

Get the impersonated user authenticated token.

requires authentication

Example request:

curl --request POST \
    "https://cloud.lektri.co/api/v1/user/a04ac243-d20e-4453-89f3-5e4de4b83338/impersonate" \
    --header "Authorization: Bearer {TOKEN}"

const url = new URL(
    "https://cloud.lektri.co/api/v1/user/a04ac243-d20e-4453-89f3-5e4de4b83338/impersonate"
);

const headers = {
    "Authorization": "Bearer {TOKEN}",
    "Accept": "application/json",
};

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

import requests
import json

url = 'https://cloud.lektri.co/api/v1/user/a04ac243-d20e-4453-89f3-5e4de4b83338/impersonate'
headers = {
  'Authorization': 'Bearer {TOKEN}'
}

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

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://cloud.lektri.co/api/v1/user/a04ac243-d20e-4453-89f3-5e4de4b83338/impersonate',
    [
        'headers' => [
            'Authorization' => 'Bearer {TOKEN}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (422):

Show headers

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 2400
x-ratelimit-remaining: 2395
vary: Origin


{
    "success": false,
    "message": "You cannot impersonate yourself.",
    "reference": "Illuminate\\Validation\\ValidationException",
    "data": null
}

Received response:

Request failed with error:

Assets

Get user's assets

requires authentication

Example request:

curl --request GET \
    --get "https://cloud.lektri.co/api/v1/assets" \
    --header "Authorization: Bearer {TOKEN}"

const url = new URL(
    "https://cloud.lektri.co/api/v1/assets"
);

const headers = {
    "Authorization": "Bearer {TOKEN}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

import requests
import json

url = 'https://cloud.lektri.co/api/v1/assets'
headers = {
  'Authorization': 'Bearer {TOKEN}'
}

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://cloud.lektri.co/api/v1/assets',
    [
        'headers' => [
            'Authorization' => 'Bearer {TOKEN}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200):

Show headers

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 2400
x-ratelimit-remaining: 2394
vary: Origin


{
    "success": true,
    "message": "All ok",
    "reference": "None",
    "data": {
        "stations": [],
        "invites": [
            {
                "id": "a04ac243-e47a-4e44-8168-3a9bb5894542",
                "token": "FiWxRa62mrAEc1EXTrtgLTiuHvbcRAkQ",
                "email": "share@lektri.co",
                "status": "PENDING",
                "type": "SHARE",
                "owner_id": "a04ac243-d20e-4453-89f3-5e4de4b83338",
                "expires_at": "2025-11-07T11:44:32.000000Z",
                "created_at": "2025-11-06T11:44:32.000000Z",
                "updated_at": "2025-11-06T11:44:32.000000Z",
                "device_type": "App\\Models\\Charger",
                "device_id": "a04ac243-e1d7-4ced-a2a3-f56974953a88",
                "device_serial": "500413",
                "owner": {
                    "id": "a04ac243-d20e-4453-89f3-5e4de4b83338",
                    "email": "docs@lektri.co",
                    "full_name": "Docs User",
                    "first_name": "Docs",
                    "last_name": "User"
                },
                "accept_url": "https://cloud.lektri.co/api/v1/invites/FiWxRa62mrAEc1EXTrtgLTiuHvbcRAkQ/accept",
                "reject_url": "https://cloud.lektri.co/api/v1/invites/FiWxRa62mrAEc1EXTrtgLTiuHvbcRAkQ/reject"
            }
        ],
        "vehicles": [
            {
                "id": "99037b42-7d49-446e-8403-f7ae6c8c8052",
                "brand": "Tesla",
                "logo": "https://cloud.lektri.co/build/images/brands/tesla.png",
                "battery": 0,
                "color": "black",
                "users": [],
                "name": "Office car",
                "meta": {
                    "integrations": []
                },
                "model": "Model X",
                "number_plate": "FM177GFK",
                "year": 2019,
                "is_default": false
            }
        ],
        "shared": {
            "chargers": []
        }
    }
}

Received response:

Request failed with error:

Get user's assets

requires authentication

Example request:

curl --request GET \
    --get "https://cloud.lektri.co/api/v1/user/items" \
    --header "Authorization: Bearer {TOKEN}"

const url = new URL(
    "https://cloud.lektri.co/api/v1/user/items"
);

const headers = {
    "Authorization": "Bearer {TOKEN}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

import requests
import json

url = 'https://cloud.lektri.co/api/v1/user/items'
headers = {
  'Authorization': 'Bearer {TOKEN}'
}

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://cloud.lektri.co/api/v1/user/items',
    [
        'headers' => [
            'Authorization' => 'Bearer {TOKEN}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200):

Show headers

cache-control: no-cache, private
content-type: application/json
x-deprecated-at: 2021-10-10T00:00:00+00:00
x-ratelimit-limit: 2400
x-ratelimit-remaining: 2340
vary: Origin


{
    "success": true,
    "message": "All ok",
    "reference": "None",
    "data": {
        "stations": [],
        "invites": [
            {
                "id": "a04ac243-e47a-4e44-8168-3a9bb5894542",
                "token": "FiWxRa62mrAEc1EXTrtgLTiuHvbcRAkQ",
                "email": "share@lektri.co",
                "status": "PENDING",
                "type": "SHARE",
                "owner_id": "a04ac243-d20e-4453-89f3-5e4de4b83338",
                "expires_at": "2025-11-07T11:44:32.000000Z",
                "created_at": "2025-11-06T11:44:32.000000Z",
                "updated_at": "2025-11-06T11:44:32.000000Z",
                "device_type": "App\\Models\\Charger",
                "device_id": "a04ac243-e1d7-4ced-a2a3-f56974953a88",
                "device_serial": "500413",
                "owner": {
                    "id": "a04ac243-d20e-4453-89f3-5e4de4b83338",
                    "email": "docs@lektri.co",
                    "full_name": "Docs User",
                    "first_name": "Docs",
                    "last_name": "User"
                },
                "accept_url": "https://cloud.lektri.co/api/v1/invites/FiWxRa62mrAEc1EXTrtgLTiuHvbcRAkQ/accept",
                "reject_url": "https://cloud.lektri.co/api/v1/invites/FiWxRa62mrAEc1EXTrtgLTiuHvbcRAkQ/reject"
            }
        ],
        "vehicles": [],
        "shared": {
            "chargers": []
        }
    }
}

Received response:

Request failed with error:

Onboard

Assign an device to a user

requires authentication

Example request:

curl --request POST \
    "https://cloud.lektri.co/api/v1/onboard/maiores/a04ac243-d20e-4453-89f3-5e4de4b83338" \
    --header "Authorization: Bearer {TOKEN}" \
    --header "Content-Type: application/json" \
    --data "{
    \"model\": \"temporibus\",
    \"gmt_offset\": 26784.5,
    \"lat\": 66.03279,
    \"lng\": 38908
}"

const url = new URL(
    "https://cloud.lektri.co/api/v1/onboard/maiores/a04ac243-d20e-4453-89f3-5e4de4b83338"
);

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

let body = {
    "model": "temporibus",
    "gmt_offset": 26784.5,
    "lat": 66.03279,
    "lng": 38908
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

import requests
import json

url = 'https://cloud.lektri.co/api/v1/onboard/maiores/a04ac243-d20e-4453-89f3-5e4de4b83338'
payload = {
    "model": "temporibus",
    "gmt_offset": 26784.5,
    "lat": 66.03279,
    "lng": 38908
}
headers = {
  'Authorization': 'Bearer {TOKEN}',
  'Content-Type': 'application/json'
}

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

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://cloud.lektri.co/api/v1/onboard/maiores/a04ac243-d20e-4453-89f3-5e4de4b83338',
    [
        'headers' => [
            'Authorization' => 'Bearer {TOKEN}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'model' => 'temporibus',
            'gmt_offset' => 26784.5,
            'lat' => 66.03279,
            'lng' => 38908.0,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (403):

Show headers

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 2400
x-ratelimit-remaining: 2368
vary: Origin


{
    "success": false,
    "message": "You are not allowed to assign devices!",
    "reference": "None",
    "data": null
}

Received response:

Request failed with error:

Request

POST api/v1/onboard/{serial}/{user_id}

Headers

Authorization

Example: Bearer {TOKEN}

Content-Type

Example: application/json

URL Parameters

serial string

Example: maiores

user_id string

The ID of the user. Example: a04ac243-d20e-4453-89f3-5e4de4b83338

Body Parameters

station_id string optional

The id of an existing record in the stations table.

model string optional

Example: temporibus

gmt_offset number optional

Example: 26784.5

lat number optional

Example: 66.03279

lng number optional

Example: 38908

Offboard a device

requires authentication

Example request:

curl --request DELETE \
    "https://cloud.lektri.co/api/v1/offboard/eos" \
    --header "Authorization: Bearer {TOKEN}"

const url = new URL(
    "https://cloud.lektri.co/api/v1/offboard/eos"
);

const headers = {
    "Authorization": "Bearer {TOKEN}",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

import requests
import json

url = 'https://cloud.lektri.co/api/v1/offboard/eos'
headers = {
  'Authorization': 'Bearer {TOKEN}'
}

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

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://cloud.lektri.co/api/v1/offboard/eos',
    [
        'headers' => [
            'Authorization' => 'Bearer {TOKEN}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (404):

Show headers

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 2400
x-ratelimit-remaining: 2367
vary: Origin


{
    "success": false,
    "message": "Device not found!",
    "reference": "None",
    "data": null
}

Received response:

Request failed with error:

Sessions

Get all sessions

requires authentication

Example request:

curl --request GET \
    --get "https://cloud.lektri.co/api/v1/sessions" \
    --header "Authorization: Bearer {TOKEN}" \
    --header "Content-Type: application/json" \
    --data "{
    \"filter\": {
        \"starts_after\": \"2025-11-06T11:44:33\",
        \"ends_before\": \"2025-11-06T11:44:33\"
    }
}"

const url = new URL(
    "https://cloud.lektri.co/api/v1/sessions"
);

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

let body = {
    "filter": {
        "starts_after": "2025-11-06T11:44:33",
        "ends_before": "2025-11-06T11:44:33"
    }
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

import requests
import json

url = 'https://cloud.lektri.co/api/v1/sessions'
payload = {
    "filter": {
        "starts_after": "2025-11-06T11:44:33",
        "ends_before": "2025-11-06T11:44:33"
    }
}
headers = {
  'Authorization': 'Bearer {TOKEN}',
  'Content-Type': 'application/json'
}

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://cloud.lektri.co/api/v1/sessions',
    [
        'headers' => [
            'Authorization' => 'Bearer {TOKEN}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'filter' => [
                'starts_after' => '2025-11-06T11:44:33',
                'ends_before' => '2025-11-06T11:44:33',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200):

Show headers

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 2400
x-ratelimit-remaining: 2393
vary: Origin


{
    "data": [],
    "links": {
        "first": "https://cloud.lektri.co/api/v1/sessions?page=1",
        "last": "https://cloud.lektri.co/api/v1/sessions?page=1",
        "prev": null,
        "next": null
    },
    "meta": {
        "current_page": 1,
        "from": null,
        "last_page": 1,
        "links": [
            {
                "url": null,
                "label": "&laquo; Previous",
                "active": false
            },
            {
                "url": "https://cloud.lektri.co/api/v1/sessions?page=1",
                "label": "1",
                "active": true
            },
            {
                "url": null,
                "label": "Next &raquo;",
                "active": false
            }
        ],
        "path": "https://cloud.lektri.co/api/v1/sessions",
        "per_page": 15,
        "to": null,
        "total": 0
    },
    "success": true,
    "message": "All ok",
    "reference": "None"
}

Received response:

Request failed with error:

Request

GET api/v1/sessions

Headers

Authorization

Example: Bearer {TOKEN}

Content-Type

Example: application/json

Body Parameters

filter object optional

starts_after string

Must be a valid date. Example: 2025-11-06T11:44:33

ends_before string

Must be a valid date. Example: 2025-11-06T11:44:33

owner_id string optional

charger_id string optional

Get all sessions extra

requires authentication

Example request:

curl --request GET \
    --get "https://cloud.lektri.co/api/v1/sessions/extra" \
    --header "Authorization: Bearer {TOKEN}" \
    --header "Content-Type: application/json" \
    --data "{
    \"filter\": {
        \"starts_after\": \"2025-11-06T11:44:33\",
        \"ends_before\": \"2025-11-06T11:44:33\"
    }
}"

const url = new URL(
    "https://cloud.lektri.co/api/v1/sessions/extra"
);

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

let body = {
    "filter": {
        "starts_after": "2025-11-06T11:44:33",
        "ends_before": "2025-11-06T11:44:33"
    }
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

import requests
import json

url = 'https://cloud.lektri.co/api/v1/sessions/extra'
payload = {
    "filter": {
        "starts_after": "2025-11-06T11:44:33",
        "ends_before": "2025-11-06T11:44:33"
    }
}
headers = {
  'Authorization': 'Bearer {TOKEN}',
  'Content-Type': 'application/json'
}

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://cloud.lektri.co/api/v1/sessions/extra',
    [
        'headers' => [
            'Authorization' => 'Bearer {TOKEN}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'filter' => [
                'starts_after' => '2025-11-06T11:44:33',
                'ends_before' => '2025-11-06T11:44:33',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200):

Show headers

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 2400
x-ratelimit-remaining: 2392
vary: Origin


{
    "success": true,
    "message": "All ok",
    "reference": "None",
    "data": {
        "total_sessios": 0,
        "total_energy": 0,
        "green_energy": 0,
        "trees": "0",
        "unit": "kWh",
        "graph": {
            "labels": [
                "06"
            ],
            "tooltip": [
                "Nov 6, 2025"
            ],
            "type": "week",
            "datasets": [
                {
                    "label": "Total energy (kWh)",
                    "slug": "charts.total_energy",
                    "data": [
                        0
                    ],
                    "backgroundColor": "rgb(37, 99, 235)"
                },
                {
                    "label": "Green energy (kWh)",
                    "slug": "charts.green_energy",
                    "data": [
                        0
                    ],
                    "backgroundColor": "rgb(52, 211, 153)"
                }
            ]
        }
    }
}

Received response:

Request failed with error:

Request

GET api/v1/sessions/extra

Headers

Authorization

Example: Bearer {TOKEN}

Content-Type

Example: application/json

Body Parameters

filter object optional

starts_after string

Must be a valid date. Example: 2025-11-06T11:44:33

ends_before string

Must be a valid date. Example: 2025-11-06T11:44:33

owner_id string optional

charger_id string optional

Get specific sessions

requires authentication

Example request:

curl --request GET \
    --get "https://cloud.lektri.co/api/v1/sessions/99037b42-7d49-446e-8403-f7ae6c8c8052" \
    --header "Authorization: Bearer {TOKEN}"

const url = new URL(
    "https://cloud.lektri.co/api/v1/sessions/99037b42-7d49-446e-8403-f7ae6c8c8052"
);

const headers = {
    "Authorization": "Bearer {TOKEN}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

import requests
import json

url = 'https://cloud.lektri.co/api/v1/sessions/99037b42-7d49-446e-8403-f7ae6c8c8052'
headers = {
  'Authorization': 'Bearer {TOKEN}'
}

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://cloud.lektri.co/api/v1/sessions/99037b42-7d49-446e-8403-f7ae6c8c8052',
    [
        'headers' => [
            'Authorization' => 'Bearer {TOKEN}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200):

Show headers

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 2400
x-ratelimit-remaining: 2391
vary: Origin


{
    "success": true,
    "message": "All ok",
    "reference": "None",
    "data": {
        "id": "99037b42-7d49-446e-8403-f7ae6c8c8052",
        "transaction_id": "836486",
        "tag_id": null,
        "session_id": 1,
        "meter": 0,
        "meter_start": 0,
        "meter_end": 5559,
        "green_energy": 5489,
        "status": "CREATED",
        "reason": "DISCONNECT",
        "is_archived": 0,
        "charger_id": "a04ac243-e1d7-4ced-a2a3-f56974953a88",
        "owner_id": "a04ac243-d20e-4453-89f3-5e4de4b83338",
        "vehicle_id": null,
        "meta": [],
        "created_at": "2025-10-10T11:44:32.000000Z",
        "updated_at": "2025-11-06T11:44:32.000000Z",
        "duration": "00:20:34",
        "charge_time": 1234,
        "charger": {
            "id": "a04ac243-e1d7-4ced-a2a3-f56974953a88",
            "serial": "500413",
            "name": "Charger 529356",
            "model": "1P7K",
            "status": "UNKNOWN",
            "status_extended": null,
            "limit": "HARDWARE",
            "gmt_offset": 2,
            "meta": {
                "extended_charger_state": null,
                "config": [],
                "boot": [],
                "notify": []
            },
            "lat": 45.1234,
            "lng": 23.1234,
            "country": "RO",
            "auth": 0,
            "ip": "192.168.0.1",
            "em": 0,
            "owner_id": "a04ac243-d20e-4453-89f3-5e4de4b83338",
            "schedule": 0,
            "led": 100,
            "user_current": 16,
            "install_current": 32,
            "pwm_mode": 0,
            "firmware": "1.40",
            "ocpp_server_link": "ws://ocpp.lektri.co",
            "phase": 1,
            "type": "PRIVATE",
            "topic": "1p7k_529356",
            "network": "DISCONNECTED",
            "status_at": "2025-11-06 13:44:32",
            "connected": true,
            "is_shared": false,
            "owner": {
                "id": "a04ac243-d20e-4453-89f3-5e4de4b83338",
                "email": "docs@lektri.co",
                "name": "Docs User",
                "full_name": "Docs User",
                "tag": "0GOUwD9Dzl"
            },
            "users": [],
            "station": {
                "id": "a04ac243-dbbe-4f4c-b390-31b2f8e65a2f",
                "name": "Lewis Strosin Jr.",
                "lat": "45.7573346",
                "lng": "21.2236252",
                "is_default": false
            },
            "integrations": [],
            "is_default": false
        },
        "green": {
            "graph": {
                "labels": [
                    "13:42:32",
                    "13:43:02",
                    "13:43:32",
                    "13:44:02"
                ],
                "active_power": [
                    0,
                    0,
                    0,
                    0
                ],
                "chargers_list_instant_power": [
                    0,
                    0,
                    0,
                    0
                ],
                "green_power": [
                    0,
                    0,
                    0,
                    0
                ]
            },
            "total_energy": 0,
            "total_green": 0,
            "green_percent": 0
        },
        "graph": null
    }
}

Received response:

Request failed with error:

Get specific sessions extra

requires authentication

Example request:

curl --request GET \
    --get "https://cloud.lektri.co/api/v1/session/99037b42-7d49-446e-8403-f7ae6c8c8052/extra" \
    --header "Authorization: Bearer {TOKEN}"

const url = new URL(
    "https://cloud.lektri.co/api/v1/session/99037b42-7d49-446e-8403-f7ae6c8c8052/extra"
);

const headers = {
    "Authorization": "Bearer {TOKEN}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

import requests
import json

url = 'https://cloud.lektri.co/api/v1/session/99037b42-7d49-446e-8403-f7ae6c8c8052/extra'
headers = {
  'Authorization': 'Bearer {TOKEN}'
}

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://cloud.lektri.co/api/v1/session/99037b42-7d49-446e-8403-f7ae6c8c8052/extra',
    [
        'headers' => [
            'Authorization' => 'Bearer {TOKEN}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200):

Show headers

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 2400
x-ratelimit-remaining: 2390
vary: Origin


{
    "success": true,
    "message": "All ok",
    "reference": "None",
    "data": {
        "total_sessios": 1,
        "total_energy": 5.56,
        "green_energy": 5.49,
        "unit": "kWh",
        "trees": 0.2
    }
}

Received response:

Request failed with error:

Get all sessions

requires authentication

Example request:

curl --request GET \
    --get "https://cloud.lektri.co/api/v1/reports" \
    --header "Authorization: Bearer {TOKEN}" \
    --header "Content-Type: application/json" \
    --data "{
    \"filter\": {
        \"starts_after\": \"2025-11-06 11:44:33\",
        \"ends_before\": \"2025-11-06 11:44:33\"
    }
}"

const url = new URL(
    "https://cloud.lektri.co/api/v1/reports"
);

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

let body = {
    "filter": {
        "starts_after": "2025-11-06 11:44:33",
        "ends_before": "2025-11-06 11:44:33"
    }
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

import requests
import json

url = 'https://cloud.lektri.co/api/v1/reports'
payload = {
    "filter": {
        "starts_after": "2025-11-06 11:44:33",
        "ends_before": "2025-11-06 11:44:33"
    }
}
headers = {
  'Authorization': 'Bearer {TOKEN}',
  'Content-Type': 'application/json'
}

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://cloud.lektri.co/api/v1/reports',
    [
        'headers' => [
            'Authorization' => 'Bearer {TOKEN}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'filter' => [
                'starts_after' => '2025-11-06 11:44:33',
                'ends_before' => '2025-11-06 11:44:33',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200):

Show headers

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 2400
x-ratelimit-remaining: 2347
vary: Origin


{
    "success": true,
    "message": "All ok",
    "reference": "None",
    "data": {
        "allowed_filters": {
            "owner_id": [],
            "charger_id": {
                "500413": "a04ac243-e1d7-4ced-a2a3-f56974953a88"
            },
            "station_id": [],
            "site_id": []
        },
        "graph": {
            "labels": [],
            "tooltip": [],
            "type": "hour",
            "datasets": [
                {
                    "label": "Total energy (kWh)",
                    "slug": "charts.total_energy",
                    "data": [],
                    "backgroundColor": "rgb(37, 99, 235)"
                },
                {
                    "label": "Green energy (kWh)",
                    "slug": "charts.green_energy",
                    "data": [],
                    "backgroundColor": "rgb(52, 211, 153)"
                }
            ]
        },
        "overview": {
            "total": 0,
            "total_energy_charged": 0,
            "total_green_energy_charged": 0,
            "users_count": 0,
            "devices_count": 0,
            "stations_count": 0,
            "total_energy": 0,
            "green_energy": 0,
            "unit": "kWh",
            "green_percent": 0,
            "formated_percent": "0.00 %",
            "trees": "0"
        },
        "sessions": {
            "current_page": 1,
            "data": [],
            "first_page_url": "https://cloud.lektri.co/api/v1/reports?page=1",
            "from": null,
            "last_page": 1,
            "last_page_url": "https://cloud.lektri.co/api/v1/reports?page=1",
            "links": [
                {
                    "url": null,
                    "label": "&laquo; Previous",
                    "active": false
                },
                {
                    "url": "https://cloud.lektri.co/api/v1/reports?page=1",
                    "label": "1",
                    "active": true
                },
                {
                    "url": null,
                    "label": "Next &raquo;",
                    "active": false
                }
            ],
            "next_page_url": null,
            "path": "https://cloud.lektri.co/api/v1/reports",
            "per_page": 15,
            "prev_page_url": null,
            "to": null,
            "total": 0
        }
    }
}

Received response:

Request failed with error:

Request

GET api/v1/reports

Headers

Authorization

Example: Bearer {TOKEN}

Content-Type

Example: application/json

Body Parameters

filter object optional

starts_after string

Must be a valid date in the format Y-m-d H:i:s. Example: 2025-11-06 11:44:33

ends_before string

Must be a valid date in the format Y-m-d H:i:s. Example: 2025-11-06 11:44:33

charger_id string[] optional

The id of an existing record in the chargers table.

owner_id string[] optional

The id of an existing record in the users table.

station_id string[] optional

The id of an existing record in the stations table.

site_id string[] optional

The id of an existing record in the sites table.

Get all sessions

requires authentication

Example request:

curl --request GET \
    --get "https://cloud.lektri.co/api/v1/reports/export" \
    --header "Authorization: Bearer {TOKEN}" \
    --header "Content-Type: application/json" \
    --data "{
    \"filter\": {
        \"starts_after\": \"2025-11-06 11:44:33\",
        \"ends_before\": \"2025-11-06 11:44:33\"
    }
}"

const url = new URL(
    "https://cloud.lektri.co/api/v1/reports/export"
);

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

let body = {
    "filter": {
        "starts_after": "2025-11-06 11:44:33",
        "ends_before": "2025-11-06 11:44:33"
    }
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

import requests
import json

url = 'https://cloud.lektri.co/api/v1/reports/export'
payload = {
    "filter": {
        "starts_after": "2025-11-06 11:44:33",
        "ends_before": "2025-11-06 11:44:33"
    }
}
headers = {
  'Authorization': 'Bearer {TOKEN}',
  'Content-Type': 'application/json'
}

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://cloud.lektri.co/api/v1/reports/export',
    [
        'headers' => [
            'Authorization' => 'Bearer {TOKEN}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'filter' => [
                'starts_after' => '2025-11-06 11:44:33',
                'ends_before' => '2025-11-06 11:44:33',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (404):

Show headers

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 2400
x-ratelimit-remaining: 2346
vary: Origin


{
    "success": false,
    "message": "No sessions found for the specified period.",
    "reference": "None",
    "data": null
}

Received response:

Request failed with error:

Request

GET api/v1/reports/export

Headers

Authorization

Example: Bearer {TOKEN}

Content-Type

Example: application/json

Body Parameters

filter object optional

starts_after string

Must be a valid date in the format Y-m-d H:i:s. Example: 2025-11-06 11:44:33

ends_before string

Must be a valid date in the format Y-m-d H:i:s. Example: 2025-11-06 11:44:33

charger_id string[] optional

The id of an existing record in the chargers table.

owner_id string[] optional

The id of an existing record in the users table.

station_id string[] optional

The id of an existing record in the stations table.

site_id string[] optional

The id of an existing record in the sites table.

Interactions

Send command to charger

requires authentication

Example request:

curl --request POST \
    "https://cloud.lektri.co/api/v1/chargers/a04ac243-e1d7-4ced-a2a3-f56974953a88/command" \
    --header "Authorization: Bearer {TOKEN}" \
    --header "Content-Type: application/json" \
    --data "{
    \"command\": \"App_config.Set\",
    \"parameters\": \"{\\\"config_key\\\": \\\"KEY\\\", \\\"config_value\\\": \\\"VALUE\\\"}\"
}"

const url = new URL(
    "https://cloud.lektri.co/api/v1/chargers/a04ac243-e1d7-4ced-a2a3-f56974953a88/command"
);

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

let body = {
    "command": "App_config.Set",
    "parameters": "{\"config_key\": \"KEY\", \"config_value\": \"VALUE\"}"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

import requests
import json

url = 'https://cloud.lektri.co/api/v1/chargers/a04ac243-e1d7-4ced-a2a3-f56974953a88/command'
payload = {
    "command": "App_config.Set",
    "parameters": "{\"config_key\": \"KEY\", \"config_value\": \"VALUE\"}"
}
headers = {
  'Authorization': 'Bearer {TOKEN}',
  'Content-Type': 'application/json'
}

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

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://cloud.lektri.co/api/v1/chargers/a04ac243-e1d7-4ced-a2a3-f56974953a88/command',
    [
        'headers' => [
            'Authorization' => 'Bearer {TOKEN}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'command' => 'App_config.Set',
            'parameters' => '{"config_key": "KEY", "config_value": "VALUE"}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 2400
x-ratelimit-remaining: 2384
vary: Origin


{
    "success": false,
    "message": "This action is unauthorized.",
    "reference": "Symfony\\Component\\HttpKernel\\Exception\\AccessDeniedHttpException",
    "data": null
}

Received response:

Request failed with error:

Request

POST api/v1/chargers/{serial}/command

Headers

Authorization

Example: Bearer {TOKEN}

Content-Type

Example: application/json

URL Parameters

serial string

Example: a04ac243-e1d7-4ced-a2a3-f56974953a88

charger_serial integer

Charger serial number Example: 500413

Body Parameters

command required optional

Command string Example: App_config.Set

parameters required optional

Command parameters Example: {"config_key": "KEY", "config_value": "VALUE"}

Start a charging session using charger serial.

requires authentication

Example request:

curl --request GET \
    --get "https://cloud.lektri.co/api/v1/chargers/500413/start" \
    --header "Authorization: Bearer {TOKEN}"

const url = new URL(
    "https://cloud.lektri.co/api/v1/chargers/500413/start"
);

const headers = {
    "Authorization": "Bearer {TOKEN}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

import requests
import json

url = 'https://cloud.lektri.co/api/v1/chargers/500413/start'
headers = {
  'Authorization': 'Bearer {TOKEN}'
}

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://cloud.lektri.co/api/v1/chargers/500413/start',
    [
        'headers' => [
            'Authorization' => 'Bearer {TOKEN}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200):

Show headers

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 2400
x-ratelimit-remaining: 2383
vary: Origin


{
    "success": true,
    "message": "All ok",
    "reference": "None",
    "data": []
}

Received response:

Request failed with error:

Stop a charging session using charger serial.

requires authentication

Example request:

curl --request GET \
    --get "https://cloud.lektri.co/api/v1/chargers/500413/stop" \
    --header "Authorization: Bearer {TOKEN}"

const url = new URL(
    "https://cloud.lektri.co/api/v1/chargers/500413/stop"
);

const headers = {
    "Authorization": "Bearer {TOKEN}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

import requests
import json

url = 'https://cloud.lektri.co/api/v1/chargers/500413/stop'
headers = {
  'Authorization': 'Bearer {TOKEN}'
}

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://cloud.lektri.co/api/v1/chargers/500413/stop',
    [
        'headers' => [
            'Authorization' => 'Bearer {TOKEN}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200):

Show headers

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 2400
x-ratelimit-remaining: 2382
vary: Origin


{
    "success": true,
    "message": "All ok",
    "reference": "None",
    "data": []
}

Received response:

Request failed with error:

Get charger system currents.

requires authentication

Example request:

curl --request GET \
    --get "https://cloud.lektri.co/api/v1/chargers/500413/currents" \
    --header "Authorization: Bearer {TOKEN}"

const url = new URL(
    "https://cloud.lektri.co/api/v1/chargers/500413/currents"
);

const headers = {
    "Authorization": "Bearer {TOKEN}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

import requests
import json

url = 'https://cloud.lektri.co/api/v1/chargers/500413/currents'
headers = {
  'Authorization': 'Bearer {TOKEN}'
}

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://cloud.lektri.co/api/v1/chargers/500413/currents',
    [
        'headers' => [
            'Authorization' => 'Bearer {TOKEN}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200):

Show headers

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 2400
x-ratelimit-remaining: 2381
vary: Origin


{
    "success": true,
    "message": "All ok",
    "reference": "None",
    "data": []
}

Received response:

Request failed with error:

Get charger active errors.

requires authentication

Example request:

curl --request GET \
    --get "https://cloud.lektri.co/api/v1/chargers/500413/errors" \
    --header "Authorization: Bearer {TOKEN}"

const url = new URL(
    "https://cloud.lektri.co/api/v1/chargers/500413/errors"
);

const headers = {
    "Authorization": "Bearer {TOKEN}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

import requests
import json

url = 'https://cloud.lektri.co/api/v1/chargers/500413/errors'
headers = {
  'Authorization': 'Bearer {TOKEN}'
}

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://cloud.lektri.co/api/v1/chargers/500413/errors',
    [
        'headers' => [
            'Authorization' => 'Bearer {TOKEN}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200):

Show headers

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 2400
x-ratelimit-remaining: 2380
vary: Origin


{
    "success": true,
    "message": "All ok",
    "reference": "None",
    "data": []
}

Received response:

Request failed with error:

Send command to meter.

requires authentication

Example request:

curl --request POST \
    "https://cloud.lektri.co/api/v1/meters/810123/command" \
    --header "Authorization: Bearer {TOKEN}" \
    --header "Content-Type: application/json" \
    --data "{
    \"command\": \"App_config.Set\",
    \"parameters\": \"{\\\"config_key\\\": \\\"KEY\\\", \\\"config_value\\\": \\\"VALUE\\\"}\"
}"

const url = new URL(
    "https://cloud.lektri.co/api/v1/meters/810123/command"
);

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

let body = {
    "command": "App_config.Set",
    "parameters": "{\"config_key\": \"KEY\", \"config_value\": \"VALUE\"}"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

import requests
import json

url = 'https://cloud.lektri.co/api/v1/meters/810123/command'
payload = {
    "command": "App_config.Set",
    "parameters": "{\"config_key\": \"KEY\", \"config_value\": \"VALUE\"}"
}
headers = {
  'Authorization': 'Bearer {TOKEN}',
  'Content-Type': 'application/json'
}

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

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://cloud.lektri.co/api/v1/meters/810123/command',
    [
        'headers' => [
            'Authorization' => 'Bearer {TOKEN}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'command' => 'App_config.Set',
            'parameters' => '{"config_key": "KEY", "config_value": "VALUE"}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (404):

Show headers

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 2400
x-ratelimit-remaining: 2375
vary: Origin


{
    "success": false,
    "message": "Not Found!",
    "reference": "Symfony\\Component\\HttpKernel\\Exception\\NotFoundHttpException",
    "data": null
}

Received response:

Request failed with error:

Request

POST api/v1/meters/{meter_serial}/command

Headers

Authorization

Example: Bearer {TOKEN}

Content-Type

Example: application/json

URL Parameters

meter_serial integer

Meter serial number Example: 810123

Body Parameters

command required optional

Command string Example: App_config.Set

parameters required optional

Command parameters Example: {"config_key": "KEY", "config_value": "VALUE"}

Endpoints

GET api/v1/maintenance

requires authentication

Example request:

curl --request GET \
    --get "https://cloud.lektri.co/api/v1/maintenance" \
    --header "Authorization: Bearer {TOKEN}"

const url = new URL(
    "https://cloud.lektri.co/api/v1/maintenance"
);

const headers = {
    "Authorization": "Bearer {TOKEN}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

import requests
import json

url = 'https://cloud.lektri.co/api/v1/maintenance'
headers = {
  'Authorization': 'Bearer {TOKEN}'
}

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://cloud.lektri.co/api/v1/maintenance',
    [
        'headers' => [
            'Authorization' => 'Bearer {TOKEN}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200):

Show headers

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 2400
x-ratelimit-remaining: 2397
vary: Origin


{
    "is_scheduled": false,
    "period": null,
    "message": "No maintenance mode is scheduled"
}

Received response:

Request failed with error:

GET api/v1/invites/{invite_token}/accept

requires authentication

Example request:

curl --request GET \
    --get "https://cloud.lektri.co/api/v1/invites/a04ac243-e47a-4e44-8168-3a9bb5894542/accept" \
    --header "Authorization: Bearer {TOKEN}"

const url = new URL(
    "https://cloud.lektri.co/api/v1/invites/a04ac243-e47a-4e44-8168-3a9bb5894542/accept"
);

const headers = {
    "Authorization": "Bearer {TOKEN}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

import requests
import json

url = 'https://cloud.lektri.co/api/v1/invites/a04ac243-e47a-4e44-8168-3a9bb5894542/accept'
headers = {
  'Authorization': 'Bearer {TOKEN}'
}

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://cloud.lektri.co/api/v1/invites/a04ac243-e47a-4e44-8168-3a9bb5894542/accept',
    [
        'headers' => [
            'Authorization' => 'Bearer {TOKEN}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (404):

Show headers

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 2400
x-ratelimit-remaining: 2357
vary: Origin


{
    "success": false,
    "message": "Not Found!",
    "reference": "Symfony\\Component\\HttpKernel\\Exception\\NotFoundHttpException",
    "data": null
}

Received response:

Request failed with error:

GET api/v1/invites/{invite_token}/reject

requires authentication

Example request:

curl --request GET \
    --get "https://cloud.lektri.co/api/v1/invites/a04ac243-e47a-4e44-8168-3a9bb5894542/reject" \
    --header "Authorization: Bearer {TOKEN}"

const url = new URL(
    "https://cloud.lektri.co/api/v1/invites/a04ac243-e47a-4e44-8168-3a9bb5894542/reject"
);

const headers = {
    "Authorization": "Bearer {TOKEN}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

import requests
import json

url = 'https://cloud.lektri.co/api/v1/invites/a04ac243-e47a-4e44-8168-3a9bb5894542/reject'
headers = {
  'Authorization': 'Bearer {TOKEN}'
}

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://cloud.lektri.co/api/v1/invites/a04ac243-e47a-4e44-8168-3a9bb5894542/reject',
    [
        'headers' => [
            'Authorization' => 'Bearer {TOKEN}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (404):

Show headers

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 2400
x-ratelimit-remaining: 2356
vary: Origin


{
    "success": false,
    "message": "Not Found!",
    "reference": "Symfony\\Component\\HttpKernel\\Exception\\NotFoundHttpException",
    "data": null
}

Received response:

Request failed with error:

GET api/v1/ownership/{invite_token}/onboard

requires authentication

Example request:

curl --request GET \
    --get "https://cloud.lektri.co/api/v1/ownership/ratione/onboard" \
    --header "Authorization: Bearer {TOKEN}"

const url = new URL(
    "https://cloud.lektri.co/api/v1/ownership/ratione/onboard"
);

const headers = {
    "Authorization": "Bearer {TOKEN}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

import requests
import json

url = 'https://cloud.lektri.co/api/v1/ownership/ratione/onboard'
headers = {
  'Authorization': 'Bearer {TOKEN}'
}

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://cloud.lektri.co/api/v1/ownership/ratione/onboard',
    [
        'headers' => [
            'Authorization' => 'Bearer {TOKEN}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (404):

Show headers

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 2400
x-ratelimit-remaining: 2352
vary: Origin


{
    "success": false,
    "message": "Not Found!",
    "reference": "Symfony\\Component\\HttpKernel\\Exception\\NotFoundHttpException",
    "data": null
}

Received response:

Request failed with error:

GET api/v1/ownership/{invite_token}/ignore

requires authentication

Example request:

curl --request GET \
    --get "https://cloud.lektri.co/api/v1/ownership/eius/ignore" \
    --header "Authorization: Bearer {TOKEN}"

const url = new URL(
    "https://cloud.lektri.co/api/v1/ownership/eius/ignore"
);

const headers = {
    "Authorization": "Bearer {TOKEN}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

import requests
import json

url = 'https://cloud.lektri.co/api/v1/ownership/eius/ignore'
headers = {
  'Authorization': 'Bearer {TOKEN}'
}

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://cloud.lektri.co/api/v1/ownership/eius/ignore',
    [
        'headers' => [
            'Authorization' => 'Bearer {TOKEN}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (404):

Show headers

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 2400
x-ratelimit-remaining: 2350
vary: Origin


{
    "success": false,
    "message": "Not Found!",
    "reference": "Symfony\\Component\\HttpKernel\\Exception\\NotFoundHttpException",
    "data": null
}

Received response:

Request failed with error:

Store a newly created resource in storage.

requires authentication

Example request:

curl --request GET \
    --get "https://cloud.lektri.co/api/v1/stations/a04ac243-dbbe-4f4c-b390-31b2f8e65a2f/providers" \
    --header "Authorization: Bearer {TOKEN}"

const url = new URL(
    "https://cloud.lektri.co/api/v1/stations/a04ac243-dbbe-4f4c-b390-31b2f8e65a2f/providers"
);

const headers = {
    "Authorization": "Bearer {TOKEN}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

import requests
import json

url = 'https://cloud.lektri.co/api/v1/stations/a04ac243-dbbe-4f4c-b390-31b2f8e65a2f/providers'
headers = {
  'Authorization': 'Bearer {TOKEN}'
}

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://cloud.lektri.co/api/v1/stations/a04ac243-dbbe-4f4c-b390-31b2f8e65a2f/providers',
    [
        'headers' => [
            'Authorization' => 'Bearer {TOKEN}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200):

Show headers

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 2400
x-ratelimit-remaining: 2339
vary: Origin


{
    "success": true,
    "message": "All ok",
    "reference": "None",
    "data": {
        "currency": "RON",
        "providers": []
    }
}

Received response:

Request failed with error:

Store a newly created resource in storage.

requires authentication

Example request:

curl --request POST \
    "https://cloud.lektri.co/api/v1/tariffs" \
    --header "Authorization: Bearer {TOKEN}" \
    --header "Content-Type: application/json" \
    --data "{
    \"type\": \"STANDARD\",
    \"day_start\": \"sgjcfo\",
    \"day_end\": \"i\",
    \"time_start\": \":15|21):40\",
    \"time_end\": \":08|20):09\",
    \"currency\": \"doloremque\",
    \"import_price\": \"fugiat\",
    \"owner_id\": \"quidem\",
    \"station_id\": \"id\"
}"

const url = new URL(
    "https://cloud.lektri.co/api/v1/tariffs"
);

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

let body = {
    "type": "STANDARD",
    "day_start": "sgjcfo",
    "day_end": "i",
    "time_start": ":15|21):40",
    "time_end": ":08|20):09",
    "currency": "doloremque",
    "import_price": "fugiat",
    "owner_id": "quidem",
    "station_id": "id"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

import requests
import json

url = 'https://cloud.lektri.co/api/v1/tariffs'
payload = {
    "type": "STANDARD",
    "day_start": "sgjcfo",
    "day_end": "i",
    "time_start": ":15|21):40",
    "time_end": ":08|20):09",
    "currency": "doloremque",
    "import_price": "fugiat",
    "owner_id": "quidem",
    "station_id": "id"
}
headers = {
  'Authorization': 'Bearer {TOKEN}',
  'Content-Type': 'application/json'
}

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

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://cloud.lektri.co/api/v1/tariffs',
    [
        'headers' => [
            'Authorization' => 'Bearer {TOKEN}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'type' => 'STANDARD',
            'day_start' => 'sgjcfo',
            'day_end' => 'i',
            'time_start' => ':15|21):40',
            'time_end' => ':08|20):09',
            'currency' => 'doloremque',
            'import_price' => 'fugiat',
            'owner_id' => 'quidem',
            'station_id' => 'id',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (422):

Show headers

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 2400
x-ratelimit-remaining: 2338
vary: Origin


{
    "success": false,
    "message": "The time start format is invalid. (and 1 more error)",
    "reference": "Illuminate\\Validation\\ValidationException",
    "data": null
}

Received response:

Request failed with error:

Request

POST api/v1/tariffs

Headers

Authorization

Example: Bearer {TOKEN}

Content-Type

Example: application/json

Body Parameters

type string

Example: STANDARD

day_start string optional

This field is required when type is STANDARD. Must be at least 1 character. Must not be greater than 7 characters. Example: sgjcfo

day_end string optional

This field is required when type is STANDARD. Must be at least 1 character. Must not be greater than 7 characters. Example: i

time_start string optional

This field is required when type is STANDARD. Must match the regex /^(?:[01]\d|2[0-3]):[0-5]\d$/. Example: :15|21):40

time_end string optional

This field is required when type is STANDARD. Must match the regex /^(?:[01]\d|2[0-3]):[0-5]\d$/. Example: :08|20):09

currency string

Example: doloremque

import_price string

Example: fugiat

export_price string optional

owner_id string

Example: quidem

station_id string

Example: id

name string optional

Update resource in storage.

requires authentication

Example request:

curl --request PATCH \
    "https://cloud.lektri.co/api/v1/tariffs/nobis" \
    --header "Authorization: Bearer {TOKEN}" \
    --header "Content-Type: application/json" \
    --data "{
    \"type\": \"BASE\",
    \"day_start\": \"rubcb\",
    \"day_end\": \"bxheikn\",
    \"time_start\": \"20:09\",
    \"time_end\": \":08:20\",
    \"currency\": \"quam\",
    \"import_price\": \"neque\",
    \"owner_id\": \"et\",
    \"station_id\": \"vero\"
}"

const url = new URL(
    "https://cloud.lektri.co/api/v1/tariffs/nobis"
);

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

let body = {
    "type": "BASE",
    "day_start": "rubcb",
    "day_end": "bxheikn",
    "time_start": "20:09",
    "time_end": ":08:20",
    "currency": "quam",
    "import_price": "neque",
    "owner_id": "et",
    "station_id": "vero"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

import requests
import json

url = 'https://cloud.lektri.co/api/v1/tariffs/nobis'
payload = {
    "type": "BASE",
    "day_start": "rubcb",
    "day_end": "bxheikn",
    "time_start": "20:09",
    "time_end": ":08:20",
    "currency": "quam",
    "import_price": "neque",
    "owner_id": "et",
    "station_id": "vero"
}
headers = {
  'Authorization': 'Bearer {TOKEN}',
  'Content-Type': 'application/json'
}

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

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'https://cloud.lektri.co/api/v1/tariffs/nobis',
    [
        'headers' => [
            'Authorization' => 'Bearer {TOKEN}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'type' => 'BASE',
            'day_start' => 'rubcb',
            'day_end' => 'bxheikn',
            'time_start' => '20:09',
            'time_end' => ':08:20',
            'currency' => 'quam',
            'import_price' => 'neque',
            'owner_id' => 'et',
            'station_id' => 'vero',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (404):

Show headers

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 2400
x-ratelimit-remaining: 2337
vary: Origin


{
    "success": false,
    "message": "Not Found!",
    "reference": "Symfony\\Component\\HttpKernel\\Exception\\NotFoundHttpException",
    "data": null
}

Received response:

Request failed with error:

Request

PATCH api/v1/tariffs/{id}

Headers

Authorization

Example: Bearer {TOKEN}

Content-Type

Example: application/json

URL Parameters

id string

The ID of the tariff. Example: nobis

Body Parameters

type string

Example: BASE

day_start string optional

This field is required when type is STANDARD. Must be at least 1 character. Must not be greater than 7 characters. Example: rubcb

day_end string optional

This field is required when type is STANDARD. Must be at least 1 character. Must not be greater than 7 characters. Example: bxheikn

time_start string optional

This field is required when type is STANDARD. Must match the regex /^(?:[01]\d|2[0-3]):[0-5]\d$/. Example: 20:09

time_end string optional

This field is required when type is STANDARD. Must match the regex /^(?:[01]\d|2[0-3]):[0-5]\d$/. Example: :08:20

currency string

Example: quam

import_price string

Example: neque

export_price string optional

owner_id string

Example: et

station_id string

Example: vero

name string optional

Remove the specified resource from storage.

requires authentication

Example request:

curl --request DELETE \
    "https://cloud.lektri.co/api/v1/tariffs/ipsum" \
    --header "Authorization: Bearer {TOKEN}"

const url = new URL(
    "https://cloud.lektri.co/api/v1/tariffs/ipsum"
);

const headers = {
    "Authorization": "Bearer {TOKEN}",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

import requests
import json

url = 'https://cloud.lektri.co/api/v1/tariffs/ipsum'
headers = {
  'Authorization': 'Bearer {TOKEN}'
}

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

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://cloud.lektri.co/api/v1/tariffs/ipsum',
    [
        'headers' => [
            'Authorization' => 'Bearer {TOKEN}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (404):

Show headers

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 2400
x-ratelimit-remaining: 2336
vary: Origin


{
    "success": false,
    "message": "Not Found!",
    "reference": "Symfony\\Component\\HttpKernel\\Exception\\NotFoundHttpException",
    "data": null
}

Received response:

Request failed with error:

Display a listing of the resource.

requires authentication

Example request:

curl --request GET \
    --get "https://cloud.lektri.co/api/v1/surveys" \
    --header "Authorization: Bearer {TOKEN}" \

const url = new URL(
    "https://cloud.lektri.co/api/v1/surveys"
);

const headers = {
    "Authorization": "Bearer {TOKEN}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

import requests
import json

url = 'https://cloud.lektri.co/api/v1/surveys'
headers = {
  'Authorization': 'Bearer {TOKEN}'
}

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://cloud.lektri.co/api/v1/surveys',
    [
        'headers' => [
            'Authorization' => 'Bearer {TOKEN}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (422):

Show headers

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 2400
x-ratelimit-remaining: 2335
vary: Origin


{
    "success": false,
    "message": "Invalid country",
    "reference": "None",
    "data": null
}

Received response:

Request failed with error:

Show the form for creating a new resource.

requires authentication

Example request:

curl --request POST \
    "https://cloud.lektri.co/api/v1/surveys/sit/entry" \
    --header "Authorization: Bearer {TOKEN}" \
    --header "Content-Type: application/json" \
    --data "{
    \"response\": \"quod\"
}"

const url = new URL(
    "https://cloud.lektri.co/api/v1/surveys/sit/entry"
);

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

let body = {
    "response": "quod"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

import requests
import json

url = 'https://cloud.lektri.co/api/v1/surveys/sit/entry'
payload = {
    "response": "quod"
}
headers = {
  'Authorization': 'Bearer {TOKEN}',
  'Content-Type': 'application/json'
}

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

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://cloud.lektri.co/api/v1/surveys/sit/entry',
    [
        'headers' => [
            'Authorization' => 'Bearer {TOKEN}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'response' => 'quod',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (404):

Show headers

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 2400
x-ratelimit-remaining: 2334
vary: Origin


{
    "success": false,
    "message": "Not Found!",
    "reference": "Symfony\\Component\\HttpKernel\\Exception\\NotFoundHttpException",
    "data": null
}

Received response:

Request failed with error:

Request

POST api/v1/surveys/{survey_id}/entry

Headers

Authorization

Example: Bearer {TOKEN}

Content-Type

Example: application/json

URL Parameters

survey_id string

The ID of the survey. Example: sit

Body Parameters

response string

Example: quod

Vehicles

Get all user's vehicles

requires authentication

Example request:

curl --request GET \
    --get "https://cloud.lektri.co/api/v1/vehicles" \
    --header "Authorization: Bearer {TOKEN}"

const url = new URL(
    "https://cloud.lektri.co/api/v1/vehicles"
);

const headers = {
    "Authorization": "Bearer {TOKEN}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

import requests
import json

url = 'https://cloud.lektri.co/api/v1/vehicles'
headers = {
  'Authorization': 'Bearer {TOKEN}'
}

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://cloud.lektri.co/api/v1/vehicles',
    [
        'headers' => [
            'Authorization' => 'Bearer {TOKEN}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200):

Show headers

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 2400
x-ratelimit-remaining: 2374
vary: Origin


{
    "success": true,
    "message": "All ok",
    "reference": "None",
    "data": [
        {
            "id": "99037b42-7d49-446e-8403-f7ae6c8c8052",
            "brand": "Tesla",
            "logo": "https://cloud.lektri.co/build/images/brands/tesla.png",
            "battery": 0,
            "color": "black",
            "users": [],
            "name": "Office car",
            "meta": {
                "integrations": []
            },
            "model": "Model X",
            "number_plate": "FM177GFK",
            "year": 2019,
            "is_default": false
        }
    ]
}

Received response:

Request failed with error:

Get specific vehicle

requires authentication

Example request:

curl --request GET \
    --get "https://cloud.lektri.co/api/v1/vehicles/99037b42-7d49-446e-8403-f7ae6c8c8052" \
    --header "Authorization: Bearer {TOKEN}"

const url = new URL(
    "https://cloud.lektri.co/api/v1/vehicles/99037b42-7d49-446e-8403-f7ae6c8c8052"
);

const headers = {
    "Authorization": "Bearer {TOKEN}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

import requests
import json

url = 'https://cloud.lektri.co/api/v1/vehicles/99037b42-7d49-446e-8403-f7ae6c8c8052'
headers = {
  'Authorization': 'Bearer {TOKEN}'
}

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://cloud.lektri.co/api/v1/vehicles/99037b42-7d49-446e-8403-f7ae6c8c8052',
    [
        'headers' => [
            'Authorization' => 'Bearer {TOKEN}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200):

Show headers

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 2400
x-ratelimit-remaining: 2373
vary: Origin


{
    "success": true,
    "message": "All ok",
    "reference": "None",
    "data": {
        "id": "99037b42-7d49-446e-8403-f7ae6c8c8052",
        "brand": "Tesla",
        "logo": "https://cloud.lektri.co/build/images/brands/tesla.png",
        "battery": 0,
        "color": "black",
        "users": [],
        "name": "Office car",
        "meta": {
            "integrations": []
        },
        "model": "Model X",
        "number_plate": "FM177GFK",
        "year": 2019,
        "is_default": false
    }
}

Received response:

Request failed with error:

Update a vehicle.

requires authentication

Example request:

curl --request PATCH \
    "https://cloud.lektri.co/api/v1/vehicles/99037b42-7d49-446e-8403-f7ae6c8c8052" \
    --header "Authorization: Bearer {TOKEN}" \
    --header "Content-Type: application/json" \
    --data "{
    \"number_plate\": \"tolugqzg\",
    \"brand\": \"eqga\",
    \"model\": \"uwwvfvtkkicyzovwalhucj\",
    \"battery\": 216275638.58166188,
    \"range\": 0.4159,
    \"year\": 44086440.03,
    \"color\": \"non\",
    \"default\": false,
    \"name\": \"nmh\"
}"

const url = new URL(
    "https://cloud.lektri.co/api/v1/vehicles/99037b42-7d49-446e-8403-f7ae6c8c8052"
);

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

let body = {
    "number_plate": "tolugqzg",
    "brand": "eqga",
    "model": "uwwvfvtkkicyzovwalhucj",
    "battery": 216275638.58166188,
    "range": 0.4159,
    "year": 44086440.03,
    "color": "non",
    "default": false,
    "name": "nmh"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

import requests
import json

url = 'https://cloud.lektri.co/api/v1/vehicles/99037b42-7d49-446e-8403-f7ae6c8c8052'
payload = {
    "number_plate": "tolugqzg",
    "brand": "eqga",
    "model": "uwwvfvtkkicyzovwalhucj",
    "battery": 216275638.58166188,
    "range": 0.4159,
    "year": 44086440.03,
    "color": "non",
    "default": false,
    "name": "nmh"
}
headers = {
  'Authorization': 'Bearer {TOKEN}',
  'Content-Type': 'application/json'
}

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

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'https://cloud.lektri.co/api/v1/vehicles/99037b42-7d49-446e-8403-f7ae6c8c8052',
    [
        'headers' => [
            'Authorization' => 'Bearer {TOKEN}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'number_plate' => 'tolugqzg',
            'brand' => 'eqga',
            'model' => 'uwwvfvtkkicyzovwalhucj',
            'battery' => 216275638.58166188,
            'range' => 0.4159,
            'year' => 44086440.03,
            'color' => 'non',
            'default' => false,
            'name' => 'nmh',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (422):

Show headers

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 2400
x-ratelimit-remaining: 2372
vary: Origin


{
    "success": false,
    "message": "The selected brand is invalid. (and 1 more error)",
    "reference": "Illuminate\\Validation\\ValidationException",
    "data": null
}

Received response:

Request failed with error:

Request

PATCH api/v1/vehicles/{vehicle_id}

Headers

Authorization

Example: Bearer {TOKEN}

Content-Type

Example: application/json

URL Parameters

vehicle_id string

Vehicle id Example: 99037b42-7d49-446e-8403-f7ae6c8c8052

Body Parameters

number_plate string

Must match the regex /[0-9A-Z]/u. Must be at least 3 characters. Must not be greater than 16 characters. Example: tolugqzg

brand string

Must not be greater than 255 characters. Example: eqga

model string

Must not be greater than 255 characters. Example: uwwvfvtkkicyzovwalhucj

battery number

Example: 216275638.58166

range number

Example: 0.4159

year number

Example: 44086440.03

color string

Example: non

default boolean optional true false

Example: false

name string optional

Must not be greater than 255 characters. Example: nmh

Delete the specified resource.

requires authentication

Example request:

curl --request DELETE \
    "https://cloud.lektri.co/api/v1/vehicles/99037b42-7d49-446e-8403-f7ae6c8c8052" \
    --header "Authorization: Bearer {TOKEN}"

const url = new URL(
    "https://cloud.lektri.co/api/v1/vehicles/99037b42-7d49-446e-8403-f7ae6c8c8052"
);

const headers = {
    "Authorization": "Bearer {TOKEN}",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

import requests
import json

url = 'https://cloud.lektri.co/api/v1/vehicles/99037b42-7d49-446e-8403-f7ae6c8c8052'
headers = {
  'Authorization': 'Bearer {TOKEN}'
}

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

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://cloud.lektri.co/api/v1/vehicles/99037b42-7d49-446e-8403-f7ae6c8c8052',
    [
        'headers' => [
            'Authorization' => 'Bearer {TOKEN}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200):

Show headers

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 2400
x-ratelimit-remaining: 2371
vary: Origin


{
    "success": true,
    "message": "All ok",
    "reference": "None",
    "data": []
}

Received response:

Request failed with error:

Register new vehicle

requires authentication

Example request:

curl --request POST \
    "https://cloud.lektri.co/api/v1/vehicles" \
    --header "Authorization: Bearer {TOKEN}" \
    --header "Content-Type: application/json" \
    --data "{
    \"number_plate\": \"huvb\",
    \"brand\": \"fyxporqzkjsurxnfuydjaocm\",
    \"model\": \"fkedvofimjxmlzhqrr\",
    \"battery\": 467285825.19,
    \"range\": 272916491.0038007,
    \"year\": 6166756.492231,
    \"color\": \"ut\",
    \"default\": true,
    \"name\": \"evtghfkqrtwbm\"
}"

const url = new URL(
    "https://cloud.lektri.co/api/v1/vehicles"
);

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

let body = {
    "number_plate": "huvb",
    "brand": "fyxporqzkjsurxnfuydjaocm",
    "model": "fkedvofimjxmlzhqrr",
    "battery": 467285825.19,
    "range": 272916491.0038007,
    "year": 6166756.492231,
    "color": "ut",
    "default": true,
    "name": "evtghfkqrtwbm"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

import requests
import json

url = 'https://cloud.lektri.co/api/v1/vehicles'
payload = {
    "number_plate": "huvb",
    "brand": "fyxporqzkjsurxnfuydjaocm",
    "model": "fkedvofimjxmlzhqrr",
    "battery": 467285825.19,
    "range": 272916491.0038007,
    "year": 6166756.492231,
    "color": "ut",
    "default": true,
    "name": "evtghfkqrtwbm"
}
headers = {
  'Authorization': 'Bearer {TOKEN}',
  'Content-Type': 'application/json'
}

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

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://cloud.lektri.co/api/v1/vehicles',
    [
        'headers' => [
            'Authorization' => 'Bearer {TOKEN}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'number_plate' => 'huvb',
            'brand' => 'fyxporqzkjsurxnfuydjaocm',
            'model' => 'fkedvofimjxmlzhqrr',
            'battery' => 467285825.19,
            'range' => 272916491.0038007,
            'year' => 6166756.492231,
            'color' => 'ut',
            'default' => true,
            'name' => 'evtghfkqrtwbm',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (422):

Show headers

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 2400
x-ratelimit-remaining: 2370
vary: Origin


{
    "success": false,
    "message": "The selected brand is invalid. (and 1 more error)",
    "reference": "Illuminate\\Validation\\ValidationException",
    "data": null
}

Received response:

Request failed with error:

Request

POST api/v1/vehicles

Headers

Authorization

Example: Bearer {TOKEN}

Content-Type

Example: application/json

Body Parameters

number_plate string

Must match the regex /[0-9A-Z]/u. Must be at least 3 characters. Must not be greater than 16 characters. Example: huvb

brand string

Must not be greater than 255 characters. Example: fyxporqzkjsurxnfuydjaocm

model string

Must not be greater than 255 characters. Example: fkedvofimjxmlzhqrr

battery number

Example: 467285825.19

range number

Example: 272916491.0038

year number

Example: 6166756.492231

color string

Example: ut

default boolean optional true false

Example: true

name string optional

Must not be greater than 255 characters. Example: evtghfkqrtwbm

Get a list of vehicle makers.

requires authentication

Example request:

curl --request GET \
    --get "https://cloud.lektri.co/api/v1/makers" \
    --header "Authorization: Bearer {TOKEN}"

const url = new URL(
    "https://cloud.lektri.co/api/v1/makers"
);

const headers = {
    "Authorization": "Bearer {TOKEN}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

import requests
import json

url = 'https://cloud.lektri.co/api/v1/makers'
headers = {
  'Authorization': 'Bearer {TOKEN}'
}

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://cloud.lektri.co/api/v1/makers',
    [
        'headers' => [
            'Authorization' => 'Bearer {TOKEN}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200):

Show headers

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 2400
x-ratelimit-remaining: 2369
vary: Origin


{
    "success": true,
    "message": "All ok",
    "reference": "None",
    "data": [
        {
            "logo": "https://cloud.lektri.co/build/images/brands/aiways.png",
            "brand": "Aiways",
            "models": [
                "U5"
            ]
        },
        {
            "logo": "https://cloud.lektri.co/build/images/brands/artega.png",
            "brand": "Artega",
            "models": [
                "Karo"
            ]
        },
        {
            "logo": "https://cloud.lektri.co/build/images/brands/audi.png",
            "brand": "Audi",
            "models": [
                "e-tron 55",
                "e-tron 50",
                "Q4 e-tron",
                "A6",
                "Q7 e-tron",
                "A7 55TFSI E",
                "e-tron S",
                "Q4 Sportback e-tron",
                "Q5 55 TFSI",
                "A3 Sportback 40 e-tron"
            ]
        },
        {
            "logo": "https://cloud.lektri.co/build/images/brands/bmw.png",
            "brand": "BMW",
            "models": [
                "i3",
                "i3S",
                "i8",
                "iX3",
                "X1",
                "X2",
                "X3",
                "X5",
                "745Le",
                "740 E",
                "545",
                "330e",
                "530e",
                "225XE"
            ]
        },
        {
            "logo": "https://cloud.lektri.co/build/images/brands/chevrolet.png",
            "brand": "Chevrolet",
            "models": [
                "Bolt",
                "Spark"
            ]
        },
        {
            "logo": "https://cloud.lektri.co/build/images/brands/citroen.png",
            "brand": "Citroën",
            "models": [
                "ë-Spacetourer",
                "Berlingo Electric",
                "C-Zero",
                "Ami",
                "C5",
                "ë-C4",
                "DS3",
                "DS5",
                "DS7"
            ]
        },
        {
            "logo": "https://cloud.lektri.co/build/images/brands/cupra.png",
            "brand": "CUPRA",
            "models": [
                "Born"
            ]
        },
        {
            "logo": "https://cloud.lektri.co/build/images/brands/dacia.png",
            "brand": "Dacia",
            "models": [
                "Spring Electric"
            ]
        },
        {
            "logo": "https://cloud.lektri.co/build/images/brands/ego.png",
            "brand": "e.GO Mobile",
            "models": [
                "Life 20",
                "Life 40",
                "Life 60"
            ]
        },
        {
            "logo": "https://cloud.lektri.co/build/images/brands/electra.png",
            "brand": "Electra",
            "models": [
                "QUDS CAPITAL",
                "QUDS EE",
                "SOLO"
            ]
        },
        {
            "logo": "https://cloud.lektri.co/build/images/brands/fiat.png",
            "brand": "Fiat",
            "models": [
                "500e"
            ]
        },
        {
            "logo": "https://cloud.lektri.co/build/images/brands/ford.png",
            "brand": "Ford",
            "models": [
                "Focus Electric",
                "Mustang Mach-E",
                "Kuga"
            ]
        },
        {
            "logo": "https://cloud.lektri.co/build/images/brands/hiphi.png",
            "brand": "HiPhi",
            "models": [
                "X"
            ]
        },
        {
            "logo": "https://cloud.lektri.co/build/images/brands/honda.png",
            "brand": "Honda",
            "models": [
                "Clarity",
                "e"
            ]
        },
        {
            "logo": "https://cloud.lektri.co/build/images/brands/hyundai.png",
            "brand": "Hyundai",
            "models": [
                "Ioniq",
                "Kona"
            ]
        },
        {
            "logo": "https://cloud.lektri.co/build/images/brands/jaguar.png",
            "brand": "Jaguar",
            "models": [
                "I-Pace"
            ]
        },
        {
            "logo": "https://cloud.lektri.co/build/images/brands/jeep.png",
            "brand": "Jeep",
            "models": [
                "Renegade 4xe"
            ]
        },
        {
            "logo": "https://cloud.lektri.co/build/images/brands/kandi.png",
            "brand": "Kandi",
            "models": [
                "K23",
                "K27"
            ]
        },
        {
            "logo": "https://cloud.lektri.co/build/images/brands/kia.png",
            "brand": "Kia",
            "models": [
                "Soul",
                "Niro",
                "EV6",
                "Ceed SW",
                "XCeed"
            ]
        },
        {
            "logo": "https://cloud.lektri.co/build/images/brands/mahindra.png",
            "brand": "Mahindra",
            "models": [
                "e2o Plus",
                "e-Verito"
            ]
        },
        {
            "logo": "https://cloud.lektri.co/build/images/brands/mazda.png",
            "brand": "Mazda",
            "models": [
                "MX-30"
            ]
        },
        {
            "logo": "https://cloud.lektri.co/build/images/brands/mercedes.png",
            "brand": "Mercedes-Benz",
            "models": [
                "EQA",
                "EQC",
                "C 300",
                "GLE",
                "E 300",
                "E 350",
                "A 250 e",
                "eVito",
                "EQV",
                "GLC 300 de 4MATIC",
                "CLA 250",
                "B-Class Electric Drive"
            ]
        },
        {
            "logo": "https://cloud.lektri.co/build/images/brands/mg.png",
            "brand": "MG",
            "models": [
                "MG5",
                "ZS"
            ]
        },
        {
            "logo": "https://cloud.lektri.co/build/images/brands/mini.png",
            "brand": "Mini",
            "models": [
                "Cooper SE",
                "Countryman ALL4"
            ]
        },
        {
            "logo": "https://cloud.lektri.co/build/images/brands/mitsubishi.png",
            "brand": "Mitsubishi",
            "models": [
                "i-MiEV",
                "Outlander PHEV"
            ]
        },
        {
            "logo": "https://cloud.lektri.co/build/images/brands/nio.png",
            "brand": "NIO",
            "models": [
                "ES6",
                "ES8"
            ]
        },
        {
            "logo": "https://cloud.lektri.co/build/images/brands/nissan.png",
            "brand": "Nissan",
            "models": [
                "Leaf",
                "e-NV 200"
            ]
        },
        {
            "logo": "https://cloud.lektri.co/build/images/brands/opel.png",
            "brand": "Opel",
            "models": [
                "Ampera e",
                "Ampera e-Pionier",
                "Corsa-e",
                "Mokka-e",
                "Vivaro-e",
                "Zafira e-life"
            ]
        },
        {
            "logo": "https://cloud.lektri.co/build/images/brands/peugeot.png",
            "brand": "Peugeot",
            "models": [
                "iOn",
                "e208",
                "e2008",
                "Partner",
                "E-Traveller",
                "3008"
            ]
        },
        {
            "logo": "https://cloud.lektri.co/build/images/brands/polestar.png",
            "brand": "Polestar",
            "models": [
                "2"
            ]
        },
        {
            "logo": "https://cloud.lektri.co/build/images/brands/porsche.png",
            "brand": "Porsche",
            "models": [
                "Taycan",
                "Cayene Hybrid"
            ]
        },
        {
            "logo": "https://cloud.lektri.co/build/images/brands/renault.png",
            "brand": "Renault",
            "models": [
                "Fluence",
                "Zoe",
                "Twizy",
                "Kangoo",
                "Twingo",
                "Captur"
            ]
        },
        {
            "logo": "https://cloud.lektri.co/build/images/brands/rimac.png",
            "brand": "Rimac",
            "models": [
                "Concept One",
                "Concept S",
                "C_Two"
            ]
        },
        {
            "logo": "https://cloud.lektri.co/build/images/brands/rivian.png",
            "brand": "Rivian",
            "models": [
                "R1T"
            ]
        },
        {
            "logo": "https://cloud.lektri.co/build/images/brands/seat.png",
            "brand": "Seat",
            "models": [
                "Mii Electric",
                "Leon eHybrid"
            ]
        },
        {
            "logo": "https://cloud.lektri.co/build/images/brands/skoda.png",
            "brand": "Skoda",
            "models": [
                "CITIGOe IV",
                "Enyaq iV",
                "Superb iV",
                "Octavia"
            ]
        },
        {
            "logo": "https://cloud.lektri.co/build/images/brands/smart.png",
            "brand": "Smart",
            "models": [
                "fortwo EQ",
                "fortwo ED",
                "forfour EQ"
            ]
        },
        {
            "logo": "https://cloud.lektri.co/build/images/brands/tesla.png",
            "brand": "Tesla",
            "models": [
                "Model 3",
                "Model S",
                "Model X",
                "Model Y"
            ]
        },
        {
            "logo": "https://cloud.lektri.co/build/images/brands/volvo.png",
            "brand": "Volvo",
            "models": [
                "XC40",
                "XC40 PHEV",
                "XC60 Plugin-Hybrid"
            ]
        },
        {
            "logo": "https://cloud.lektri.co/build/images/brands/vw.png",
            "brand": "Volkswagen",
            "models": [
                "e-up!",
                "e-Golf",
                "ID.3",
                "ID.4",
                "Golf GTE",
                "Passat GTE"
            ]
        },
        {
            "logo": "https://cloud.lektri.co/build/images/brands/xpeng.png",
            "brand": "Xpeng",
            "models": [
                "G3",
                "P7"
            ]
        },
        {
            "logo": "https://cloud.lektri.co/build/images/brands/other.png",
            "brand": "Other",
            "models": [
                "Other"
            ]
        }
    ]
}

Received response:

Request failed with error:

Charger

Get specific charger

requires authentication

Example request:

curl --request GET \
    --get "https://cloud.lektri.co/api/v1/chargers/500413" \
    --header "Authorization: Bearer {TOKEN}"

const url = new URL(
    "https://cloud.lektri.co/api/v1/chargers/500413"
);

const headers = {
    "Authorization": "Bearer {TOKEN}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

import requests
import json

url = 'https://cloud.lektri.co/api/v1/chargers/500413'
headers = {
  'Authorization': 'Bearer {TOKEN}'
}

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://cloud.lektri.co/api/v1/chargers/500413',
    [
        'headers' => [
            'Authorization' => 'Bearer {TOKEN}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200):

Show headers

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 2400
x-ratelimit-remaining: 2388
vary: Origin


{
    "success": true,
    "message": "All ok",
    "reference": "None",
    "data": {
        "id": "a04ac243-e1d7-4ced-a2a3-f56974953a88",
        "serial": "500413",
        "name": "Charger 529356",
        "model": "1P7K",
        "status": "UNKNOWN",
        "status_extended": null,
        "limit": "HARDWARE",
        "gmt_offset": 2,
        "meta": {
            "extended_charger_state": null,
            "config": [],
            "boot": [],
            "notify": []
        },
        "lat": 45.1234,
        "lng": 23.1234,
        "country": "RO",
        "auth": 0,
        "ip": "192.168.0.1",
        "em": 0,
        "owner_id": "a04ac243-d20e-4453-89f3-5e4de4b83338",
        "schedule": 0,
        "led": 100,
        "user_current": 16,
        "install_current": 32,
        "pwm_mode": 0,
        "firmware": "1.40",
        "ocpp_server_link": "ws://ocpp.lektri.co",
        "phase": 1,
        "type": "PRIVATE",
        "topic": "1p7k_529356",
        "network": "DISCONNECTED",
        "status_at": "2025-11-06 13:44:32",
        "connected": true,
        "is_shared": false,
        "owner": {
            "id": "a04ac243-d20e-4453-89f3-5e4de4b83338",
            "email": "docs@lektri.co",
            "name": "Docs User",
            "full_name": "Docs User",
            "tag": "0GOUwD9Dzl"
        },
        "users": [],
        "station": {
            "id": "a04ac243-dbbe-4f4c-b390-31b2f8e65a2f",
            "name": "Lewis Strosin Jr.",
            "lat": "45.7573346",
            "lng": "21.2236252",
            "is_default": false
        },
        "integrations": [],
        "is_default": false
    }
}

Received response:

Request failed with error:

Update charger

requires authentication

Example request:

curl --request PATCH \
    "https://cloud.lektri.co/api/v1/chargers/500413" \
    --header "Authorization: Bearer {TOKEN}" \
    --header "Content-Type: application/json" \
    --data "{
    \"model\": \"sit\",
    \"station_id\": \"quod\",
    \"lat\": 139121219.3998,
    \"lng\": 429.07,
    \"current\": 4.45364,
    \"gmt_offset\": 19.3,
    \"serial\": \"285501\",
    \"station_name\": \"aut\"
}"

const url = new URL(
    "https://cloud.lektri.co/api/v1/chargers/500413"
);

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

let body = {
    "model": "sit",
    "station_id": "quod",
    "lat": 139121219.3998,
    "lng": 429.07,
    "current": 4.45364,
    "gmt_offset": 19.3,
    "serial": "285501",
    "station_name": "aut"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

import requests
import json

url = 'https://cloud.lektri.co/api/v1/chargers/500413'
payload = {
    "model": "sit",
    "station_id": "quod",
    "lat": 139121219.3998,
    "lng": 429.07,
    "current": 4.45364,
    "gmt_offset": 19.3,
    "serial": "285501",
    "station_name": "aut"
}
headers = {
  'Authorization': 'Bearer {TOKEN}',
  'Content-Type': 'application/json'
}

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

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'https://cloud.lektri.co/api/v1/chargers/500413',
    [
        'headers' => [
            'Authorization' => 'Bearer {TOKEN}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'model' => 'sit',
            'station_id' => 'quod',
            'lat' => 139121219.3998,
            'lng' => 429.07,
            'current' => 4.45364,
            'gmt_offset' => 19.3,
            'serial' => '285501',
            'station_name' => 'aut',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (400):

Show headers

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 2400
x-ratelimit-remaining: 2387
vary: Origin


{
    "success": false,
    "message": "SQLSTATE[23000]: Integrity constraint violation: 19 FOREIGN KEY constraint failed (Connection: sqlite, SQL: update \"chargers\" set \"lat\" = 139121219.3998, \"lng\" = 429.07, \"station_id\" = quod, \"gmt_offset\" = 19.3, \"country\" = ro, \"updated_at\" = 2025-11-06 11:44:33 where \"id\" = a04ac243-e1d7-4ced-a2a3-f56974953a88)",
    "reference": "Illuminate\\Database\\QueryException",
    "data": null
}

Received response:

Request failed with error:

Request

PATCH api/v1/chargers/{charger_serial}

Headers

Authorization

Example: Bearer {TOKEN}

Content-Type

Example: application/json

URL Parameters

charger_serial integer

Charger serial number Example: 500413

Body Parameters

model string optional

Example: sit

station_id string

Example: quod

lat number optional

Example: 139121219.3998

lng number optional

Example: 429.07

current number optional

Example: 4.45364

gmt_offset number optional

Example: 19.3

serial string optional

Must be 6 digits. Example: 285501

station_name string optional

Example: aut

Register a new charger

requires authentication

Example request:

curl --request POST \
    "https://cloud.lektri.co/api/v1/chargers" \
    --header "Authorization: Bearer {TOKEN}" \
    --header "Content-Type: application/json" \
    --data "{
    \"model\": \"laborum\",
    \"serial\": \"823078\",
    \"station_name\": \"voluptatibus\",
    \"lat\": 25539243.009411838,
    \"lng\": 87.421,
    \"current\": 7277790.65766307,
    \"gmt_offset\": 88181
}"

const url = new URL(
    "https://cloud.lektri.co/api/v1/chargers"
);

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

let body = {
    "model": "laborum",
    "serial": "823078",
    "station_name": "voluptatibus",
    "lat": 25539243.009411838,
    "lng": 87.421,
    "current": 7277790.65766307,
    "gmt_offset": 88181
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

import requests
import json

url = 'https://cloud.lektri.co/api/v1/chargers'
payload = {
    "model": "laborum",
    "serial": "823078",
    "station_name": "voluptatibus",
    "lat": 25539243.009411838,
    "lng": 87.421,
    "current": 7277790.65766307,
    "gmt_offset": 88181
}
headers = {
  'Authorization': 'Bearer {TOKEN}',
  'Content-Type': 'application/json'
}

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

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://cloud.lektri.co/api/v1/chargers',
    [
        'headers' => [
            'Authorization' => 'Bearer {TOKEN}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'model' => 'laborum',
            'serial' => '823078',
            'station_name' => 'voluptatibus',
            'lat' => 25539243.009411838,
            'lng' => 87.421,
            'current' => 7277790.65766307,
            'gmt_offset' => 88181.0,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (404):

Show headers

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 2400
x-ratelimit-remaining: 2386
vary: Origin


{
    "success": false,
    "message": "Charger not found!",
    "reference": "None",
    "data": null
}

Received response:

Request failed with error:

Request

POST api/v1/chargers

Headers

Authorization

Example: Bearer {TOKEN}

Content-Type

Example: application/json

Body Parameters

model string

Example: laborum

serial string

Must be 6 digits. Example: 823078

station_name string

Example: voluptatibus

lat number

Example: 25539243.009412

lng number

Example: 87.421

current number

Example: 7277790.6576631

gmt_offset number optional

Example: 88181

Unregister charger

requires authentication

Example request:

curl --request DELETE \
    "https://cloud.lektri.co/api/v1/chargers/500413" \
    --header "Authorization: Bearer {TOKEN}"

const url = new URL(
    "https://cloud.lektri.co/api/v1/chargers/500413"
);

const headers = {
    "Authorization": "Bearer {TOKEN}",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

import requests
import json

url = 'https://cloud.lektri.co/api/v1/chargers/500413'
headers = {
  'Authorization': 'Bearer {TOKEN}'
}

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

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://cloud.lektri.co/api/v1/chargers/500413',
    [
        'headers' => [
            'Authorization' => 'Bearer {TOKEN}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 2400
x-ratelimit-remaining: 2385
vary: Origin


{
    "success": false,
    "message": "This action is unauthorized.",
    "reference": "Symfony\\Component\\HttpKernel\\Exception\\AccessDeniedHttpException",
    "data": null
}

Received response:

Request failed with error:

Delete shared user

requires authentication

Example request:

curl --request DELETE \
    "https://cloud.lektri.co/api/v1/chargers/500413/sharing/a04ac243-d20e-4453-89f3-5e4de4b83338" \
    --header "Authorization: Bearer {TOKEN}"

const url = new URL(
    "https://cloud.lektri.co/api/v1/chargers/500413/sharing/a04ac243-d20e-4453-89f3-5e4de4b83338"
);

const headers = {
    "Authorization": "Bearer {TOKEN}",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

import requests
import json

url = 'https://cloud.lektri.co/api/v1/chargers/500413/sharing/a04ac243-d20e-4453-89f3-5e4de4b83338'
headers = {
  'Authorization': 'Bearer {TOKEN}'
}

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

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://cloud.lektri.co/api/v1/chargers/500413/sharing/a04ac243-d20e-4453-89f3-5e4de4b83338',
    [
        'headers' => [
            'Authorization' => 'Bearer {TOKEN}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200):

Show headers

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 2400
x-ratelimit-remaining: 2348
vary: Origin


{
    "success": true,
    "message": "All ok",
    "reference": "None",
    "data": {
        "id": "a04ac243-e1d7-4ced-a2a3-f56974953a88",
        "serial": "500413",
        "name": "Charger 529356",
        "model": "1P7K",
        "status": "UNKNOWN",
        "status_extended": null,
        "limit": "HARDWARE",
        "gmt_offset": 2,
        "meta": {
            "extended_charger_state": null,
            "config": [],
            "boot": [],
            "notify": []
        },
        "lat": 45.1234,
        "lng": 23.1234,
        "country": "RO",
        "auth": 0,
        "ip": "192.168.0.1",
        "em": 0,
        "owner_id": "a04ac243-d20e-4453-89f3-5e4de4b83338",
        "schedule": 0,
        "led": 100,
        "user_current": 16,
        "install_current": 32,
        "pwm_mode": 0,
        "firmware": "1.40",
        "ocpp_server_link": "ws://ocpp.lektri.co",
        "phase": 1,
        "type": "PRIVATE",
        "topic": "1p7k_529356",
        "network": "DISCONNECTED",
        "status_at": "2025-11-06 13:44:32",
        "connected": true,
        "is_shared": false,
        "owner": {
            "id": "a04ac243-d20e-4453-89f3-5e4de4b83338",
            "email": "docs@lektri.co",
            "name": "Docs User",
            "full_name": "Docs User",
            "tag": "0GOUwD9Dzl"
        },
        "users": [],
        "station": {
            "id": "a04ac243-dbbe-4f4c-b390-31b2f8e65a2f",
            "name": "Lewis Strosin Jr.",
            "lat": "45.7573346",
            "lng": "21.2236252",
            "is_default": false
        },
        "integrations": [],
        "is_default": false
    }
}

Received response:

Request failed with error:

Firmware

Get the latest stable firmware version for a given device model

requires authentication

Example request:

curl --request GET \
    --get "https://cloud.lektri.co/api/v1/firmware/est/latest" \
    --header "Authorization: Bearer {TOKEN}"

const url = new URL(
    "https://cloud.lektri.co/api/v1/firmware/est/latest"
);

const headers = {
    "Authorization": "Bearer {TOKEN}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

import requests
import json

url = 'https://cloud.lektri.co/api/v1/firmware/est/latest'
headers = {
  'Authorization': 'Bearer {TOKEN}'
}

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://cloud.lektri.co/api/v1/firmware/est/latest',
    [
        'headers' => [
            'Authorization' => 'Bearer {TOKEN}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (404):

Show headers

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 2400
x-ratelimit-remaining: 2396
vary: Origin


{
    "success": false,
    "message": "Device not found!",
    "reference": "None",
    "data": null
}

Received response:

Request failed with error:

Check device firmware

requires authentication

Example request:

curl --request GET \
    --get "https://cloud.lektri.co/api/v1/firmware/500413/check" \
    --header "Authorization: Bearer {TOKEN}"

const url = new URL(
    "https://cloud.lektri.co/api/v1/firmware/500413/check"
);

const headers = {
    "Authorization": "Bearer {TOKEN}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

import requests
import json

url = 'https://cloud.lektri.co/api/v1/firmware/500413/check'
headers = {
  'Authorization': 'Bearer {TOKEN}'
}

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://cloud.lektri.co/api/v1/firmware/500413/check',
    [
        'headers' => [
            'Authorization' => 'Bearer {TOKEN}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (404):

Show headers

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 2400
x-ratelimit-remaining: 2389
vary: Origin


{
    "success": false,
    "message": "Firmware not found!",
    "reference": "None",
    "data": null
}

Received response:

Request failed with error:

Integrations

Get integration vendors and types.

requires authentication

Example request:

curl --request GET \
    --get "https://cloud.lektri.co/api/v1/integrations/data" \
    --header "Authorization: Bearer {TOKEN}"

const url = new URL(
    "https://cloud.lektri.co/api/v1/integrations/data"
);

const headers = {
    "Authorization": "Bearer {TOKEN}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

import requests
import json

url = 'https://cloud.lektri.co/api/v1/integrations/data'
headers = {
  'Authorization': 'Bearer {TOKEN}'
}

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://cloud.lektri.co/api/v1/integrations/data',
    [
        'headers' => [
            'Authorization' => 'Bearer {TOKEN}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200):

Show headers

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 2400
x-ratelimit-remaining: 2366
vary: Origin


{
    "success": true,
    "message": "All ok",
    "reference": "None",
    "data": {
        "vendors": [
            "Off",
            "Onboard",
            "Alfa by Sinapsi",
            "SolarEdge inverter",
            "Chain2Gate",
            "Shelly EM",
            "Shelly 3EM",
            "Shelly EM PRO",
            "Shelly 3EM PRO",
            "Generic Sunspec",
            "Deye",
            "Fronius"
        ],
        "types": [
            "METER",
            "INVERTER",
            "OTHER"
        ]
    }
}

Received response:

Request failed with error:

Display a listing of the resource.

requires authentication

Example request:

curl --request GET \
    --get "https://cloud.lektri.co/api/v1/integrations" \
    --header "Authorization: Bearer {TOKEN}"

const url = new URL(
    "https://cloud.lektri.co/api/v1/integrations"
);

const headers = {
    "Authorization": "Bearer {TOKEN}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

import requests
import json

url = 'https://cloud.lektri.co/api/v1/integrations'
headers = {
  'Authorization': 'Bearer {TOKEN}'
}

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://cloud.lektri.co/api/v1/integrations',
    [
        'headers' => [
            'Authorization' => 'Bearer {TOKEN}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200):

Show headers

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 2400
x-ratelimit-remaining: 2365
vary: Origin


{
    "data": [],
    "success": true,
    "message": "All ok",
    "reference": "None"
}

Received response:

Request failed with error:

Store a newly created resource in storage.

requires authentication

Example request:

curl --request POST \
    "https://cloud.lektri.co/api/v1/chargers/a04ac243-e1d7-4ced-a2a3-f56974953a88/integrations" \
    --header "Authorization: Bearer {TOKEN}" \
    --header "Content-Type: application/json" \
    --data "{
    \"vendor\": \"Off\",
    \"type\": \"OTHER\",
    \"model\": \"molestiae\",
    \"ip\": \"ea\",
    \"port\": \"et\",
    \"modbus\": \"nemo\"
}"

const url = new URL(
    "https://cloud.lektri.co/api/v1/chargers/a04ac243-e1d7-4ced-a2a3-f56974953a88/integrations"
);

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

let body = {
    "vendor": "Off",
    "type": "OTHER",
    "model": "molestiae",
    "ip": "ea",
    "port": "et",
    "modbus": "nemo"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

import requests
import json

url = 'https://cloud.lektri.co/api/v1/chargers/a04ac243-e1d7-4ced-a2a3-f56974953a88/integrations'
payload = {
    "vendor": "Off",
    "type": "OTHER",
    "model": "molestiae",
    "ip": "ea",
    "port": "et",
    "modbus": "nemo"
}
headers = {
  'Authorization': 'Bearer {TOKEN}',
  'Content-Type': 'application/json'
}

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

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://cloud.lektri.co/api/v1/chargers/a04ac243-e1d7-4ced-a2a3-f56974953a88/integrations',
    [
        'headers' => [
            'Authorization' => 'Bearer {TOKEN}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'vendor' => 'Off',
            'type' => 'OTHER',
            'model' => 'molestiae',
            'ip' => 'ea',
            'port' => 'et',
            'modbus' => 'nemo',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (404):

Show headers

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 2400
x-ratelimit-remaining: 2364
vary: Origin


{
    "success": false,
    "message": "Not Found!",
    "reference": "Symfony\\Component\\HttpKernel\\Exception\\NotFoundHttpException",
    "data": null
}

Received response:

Request failed with error:

Request

POST api/v1/chargers/{charger_serial}/integrations

Headers

Authorization

Example: Bearer {TOKEN}

Content-Type

Example: application/json

URL Parameters

charger_serial string

Example: a04ac243-e1d7-4ced-a2a3-f56974953a88

Body Parameters

vendor string optional

Example: Off

type string optional

Example: OTHER

model string optional

Example: molestiae

ip string optional

Example: ea

port string optional

Example: et

modbus string optional

Example: nemo

Remove the specified resource from storage.

requires authentication

Example request:

curl --request DELETE \
    "https://cloud.lektri.co/api/v1/integrations/quis" \
    --header "Authorization: Bearer {TOKEN}"

const url = new URL(
    "https://cloud.lektri.co/api/v1/integrations/quis"
);

const headers = {
    "Authorization": "Bearer {TOKEN}",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

import requests
import json

url = 'https://cloud.lektri.co/api/v1/integrations/quis'
headers = {
  'Authorization': 'Bearer {TOKEN}'
}

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

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://cloud.lektri.co/api/v1/integrations/quis',
    [
        'headers' => [
            'Authorization' => 'Bearer {TOKEN}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (404):

Show headers

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 2400
x-ratelimit-remaining: 2363
vary: Origin


{
    "success": false,
    "message": "Not Found!",
    "reference": "Symfony\\Component\\HttpKernel\\Exception\\NotFoundHttpException",
    "data": null
}

Received response:

Request failed with error:

Display the specified resource.

requires authentication

Example request:

curl --request GET \
    --get "https://cloud.lektri.co/api/v1/integrations/explicabo" \
    --header "Authorization: Bearer {TOKEN}"

const url = new URL(
    "https://cloud.lektri.co/api/v1/integrations/explicabo"
);

const headers = {
    "Authorization": "Bearer {TOKEN}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

import requests
import json

url = 'https://cloud.lektri.co/api/v1/integrations/explicabo'
headers = {
  'Authorization': 'Bearer {TOKEN}'
}

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://cloud.lektri.co/api/v1/integrations/explicabo',
    [
        'headers' => [
            'Authorization' => 'Bearer {TOKEN}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (404):

Show headers

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 2400
x-ratelimit-remaining: 2362
vary: Origin


{
    "success": false,
    "message": "Not Found!",
    "reference": "Symfony\\Component\\HttpKernel\\Exception\\NotFoundHttpException",
    "data": null
}

Received response:

Request failed with error:

Update the specified resource in storage.

requires authentication

Example request:

curl --request PATCH \
    "https://cloud.lektri.co/api/v1/integrations/harum" \
    --header "Authorization: Bearer {TOKEN}" \
    --header "Content-Type: application/json" \
    --data "{
    \"vendor\": \"hic\",
    \"model\": \"provident\",
    \"ip\": \"repellat\",
    \"port\": \"quia\",
    \"modbus\": \"consectetur\"
}"

const url = new URL(
    "https://cloud.lektri.co/api/v1/integrations/harum"
);

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

let body = {
    "vendor": "hic",
    "model": "provident",
    "ip": "repellat",
    "port": "quia",
    "modbus": "consectetur"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

import requests
import json

url = 'https://cloud.lektri.co/api/v1/integrations/harum'
payload = {
    "vendor": "hic",
    "model": "provident",
    "ip": "repellat",
    "port": "quia",
    "modbus": "consectetur"
}
headers = {
  'Authorization': 'Bearer {TOKEN}',
  'Content-Type': 'application/json'
}

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

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'https://cloud.lektri.co/api/v1/integrations/harum',
    [
        'headers' => [
            'Authorization' => 'Bearer {TOKEN}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'vendor' => 'hic',
            'model' => 'provident',
            'ip' => 'repellat',
            'port' => 'quia',
            'modbus' => 'consectetur',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (404):

Show headers

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 2400
x-ratelimit-remaining: 2361
vary: Origin


{
    "success": false,
    "message": "Not Found!",
    "reference": "Symfony\\Component\\HttpKernel\\Exception\\NotFoundHttpException",
    "data": null
}

Received response:

Request failed with error:

Request

PATCH api/v1/integrations/{id}

Headers

Authorization

Example: Bearer {TOKEN}

Content-Type

Example: application/json

URL Parameters

id string

The ID of the integration. Example: harum

Body Parameters

vendor string

Example: hic

model string

Example: provident

ip string

Example: repellat

port string

Example: quia

modbus string

Example: consectetur

Invite

List invites

requires authentication

Example request:

curl --request GET \
    --get "https://cloud.lektri.co/api/v1/invites" \
    --header "Authorization: Bearer {TOKEN}"

const url = new URL(
    "https://cloud.lektri.co/api/v1/invites"
);

const headers = {
    "Authorization": "Bearer {TOKEN}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

import requests
import json

url = 'https://cloud.lektri.co/api/v1/invites'
headers = {
  'Authorization': 'Bearer {TOKEN}'
}

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://cloud.lektri.co/api/v1/invites',
    [
        'headers' => [
            'Authorization' => 'Bearer {TOKEN}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200):

Show headers

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 2400
x-ratelimit-remaining: 2360
vary: Origin


{
    "data": [
        {
            "id": "a04ac243-e47a-4e44-8168-3a9bb5894542",
            "token": "FiWxRa62mrAEc1EXTrtgLTiuHvbcRAkQ",
            "email": "share@lektri.co",
            "status": "PENDING",
            "type": "SHARE",
            "owner_id": "a04ac243-d20e-4453-89f3-5e4de4b83338",
            "expires_at": "2025-11-07T11:44:32.000000Z",
            "created_at": "2025-11-06T11:44:32.000000Z",
            "updated_at": "2025-11-06T11:44:32.000000Z",
            "device_type": "App\\Models\\Charger",
            "device_id": "a04ac243-e1d7-4ced-a2a3-f56974953a88",
            "owner": {
                "id": "a04ac243-d20e-4453-89f3-5e4de4b83338",
                "email": "docs@lektri.co",
                "full_name": "Docs User",
                "first_name": "Docs",
                "last_name": "User"
            },
            "device": {
                "id": "a04ac243-e1d7-4ced-a2a3-f56974953a88",
                "serial": "500413",
                "topic": "1p7k_529356",
                "lat": 45.1234,
                "lng": 23.1234,
                "name": "Charger 529356",
                "image": null,
                "network": "DISCONNECTED",
                "mode": "ONLINE",
                "auth": 0,
                "model": "1P7K",
                "firmware": "1.40",
                "ota_policy": "MANAGED",
                "ota_version": null,
                "ocpp_server_link": "ws://ocpp.lektri.co",
                "connection": "SINGLEPHASE",
                "phase": 1,
                "status": "UNKNOWN",
                "limit": "HARDWARE",
                "connector": "Type 2",
                "type": "PRIVATE",
                "station_id": "a04ac243-dbbe-4f4c-b390-31b2f8e65a2f",
                "owner_id": "a04ac243-d20e-4453-89f3-5e4de4b83338",
                "installer_id": null,
                "meta": {
                    "extended_charger_state": null,
                    "config": [],
                    "boot": [],
                    "notify": []
                },
                "profiles": null,
                "status_at": "2025-11-06T11:44:32.000000Z",
                "user_current": 16,
                "pwm_mode": 0,
                "install_current": 32,
                "gmt_offset": 2,
                "platform": "esp8266",
                "schedule": 0,
                "em": 0,
                "led": 100,
                "ip": "192.168.0.1",
                "batch_run": 1,
                "batch_attempts": 0,
                "country": "RO",
                "location": [],
                "partner": "Partner",
                "shipped_at": "2025-11-06T11:44:32.000000Z",
                "retired_at": null,
                "retired_reason": null,
                "created_at": "2025-11-06T11:44:32.000000Z",
                "updated_at": "2025-11-06T11:44:32.000000Z"
            },
            "device_serial": "500413",
            "accept_url": "https://cloud.lektri.co/api/v1/invites/FiWxRa62mrAEc1EXTrtgLTiuHvbcRAkQ/accept",
            "reject_url": "https://cloud.lektri.co/api/v1/invites/FiWxRa62mrAEc1EXTrtgLTiuHvbcRAkQ/reject"
        }
    ],
    "success": true,
    "message": "All ok",
    "reference": "None"
}

Received response:

Request failed with error:

Create an invite

requires authentication

Example request:

curl --request POST \
    "https://cloud.lektri.co/api/v1/chargers/a04ac243-e1d7-4ced-a2a3-f56974953a88/invite" \
    --header "Authorization: Bearer {TOKEN}" \
    --header "Content-Type: application/json" \
    --data "{
    \"email\": \"elta.mills@example.net\"
}"

const url = new URL(
    "https://cloud.lektri.co/api/v1/chargers/a04ac243-e1d7-4ced-a2a3-f56974953a88/invite"
);

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

let body = {
    "email": "elta.mills@example.net"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

import requests
import json

url = 'https://cloud.lektri.co/api/v1/chargers/a04ac243-e1d7-4ced-a2a3-f56974953a88/invite'
payload = {
    "email": "elta.mills@example.net"
}
headers = {
  'Authorization': 'Bearer {TOKEN}',
  'Content-Type': 'application/json'
}

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

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://cloud.lektri.co/api/v1/chargers/a04ac243-e1d7-4ced-a2a3-f56974953a88/invite',
    [
        'headers' => [
            'Authorization' => 'Bearer {TOKEN}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'email' => 'elta.mills@example.net',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (404):

Show headers

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 2400
x-ratelimit-remaining: 2359
vary: Origin


{
    "success": false,
    "message": "Not Found!",
    "reference": "Symfony\\Component\\HttpKernel\\Exception\\NotFoundHttpException",
    "data": null
}

Received response:

Request failed with error:

Request

POST api/v1/chargers/{charger_serial}/invite

Headers

Authorization

Example: Bearer {TOKEN}

Content-Type

Example: application/json

URL Parameters

charger_serial string

Example: a04ac243-e1d7-4ced-a2a3-f56974953a88

Body Parameters

email string

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

Delete an invite

requires authentication

Example request:

curl --request DELETE \
    "https://cloud.lektri.co/api/v1/invites/a04ac243-e47a-4e44-8168-3a9bb5894542/delete" \
    --header "Authorization: Bearer {TOKEN}"

const url = new URL(
    "https://cloud.lektri.co/api/v1/invites/a04ac243-e47a-4e44-8168-3a9bb5894542/delete"
);

const headers = {
    "Authorization": "Bearer {TOKEN}",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

import requests
import json

url = 'https://cloud.lektri.co/api/v1/invites/a04ac243-e47a-4e44-8168-3a9bb5894542/delete'
headers = {
  'Authorization': 'Bearer {TOKEN}'
}

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

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://cloud.lektri.co/api/v1/invites/a04ac243-e47a-4e44-8168-3a9bb5894542/delete',
    [
        'headers' => [
            'Authorization' => 'Bearer {TOKEN}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (404):

Show headers

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 2400
x-ratelimit-remaining: 2358
vary: Origin


{
    "success": false,
    "message": "Not Found!",
    "reference": "Symfony\\Component\\HttpKernel\\Exception\\NotFoundHttpException",
    "data": null
}

Received response:

Request failed with error:

Create onwership invites

requires authentication

Example request:

curl --request POST \
    "https://cloud.lektri.co/api/v1/chargers/a04ac243-e1d7-4ced-a2a3-f56974953a88/owner" \
    --header "Authorization: Bearer {TOKEN}" \
    --header "Content-Type: application/json" \
    --data "{
    \"email\": \"katelin.crona@example.com\"
}"

const url = new URL(
    "https://cloud.lektri.co/api/v1/chargers/a04ac243-e1d7-4ced-a2a3-f56974953a88/owner"
);

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

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

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

import requests
import json

url = 'https://cloud.lektri.co/api/v1/chargers/a04ac243-e1d7-4ced-a2a3-f56974953a88/owner'
payload = {
    "email": "katelin.crona@example.com"
}
headers = {
  'Authorization': 'Bearer {TOKEN}',
  'Content-Type': 'application/json'
}

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

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://cloud.lektri.co/api/v1/chargers/a04ac243-e1d7-4ced-a2a3-f56974953a88/owner',
    [
        'headers' => [
            'Authorization' => 'Bearer {TOKEN}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'email' => 'katelin.crona@example.com',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (404):

Show headers

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 2400
x-ratelimit-remaining: 2355
vary: Origin


{
    "success": false,
    "message": "Not Found!",
    "reference": "Symfony\\Component\\HttpKernel\\Exception\\NotFoundHttpException",
    "data": null
}

Received response:

Request failed with error:

Request

POST api/v1/chargers/{charger_serial}/owner

Headers

Authorization

Example: Bearer {TOKEN}

Content-Type

Example: application/json

URL Parameters

charger_serial string

Example: a04ac243-e1d7-4ced-a2a3-f56974953a88

Body Parameters

email string

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

List onwership invites

requires authentication

Example request:

curl --request GET \
    --get "https://cloud.lektri.co/api/v1/ownership/list" \
    --header "Authorization: Bearer {TOKEN}"

const url = new URL(
    "https://cloud.lektri.co/api/v1/ownership/list"
);

const headers = {
    "Authorization": "Bearer {TOKEN}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

import requests
import json

url = 'https://cloud.lektri.co/api/v1/ownership/list'
headers = {
  'Authorization': 'Bearer {TOKEN}'
}

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://cloud.lektri.co/api/v1/ownership/list',
    [
        'headers' => [
            'Authorization' => 'Bearer {TOKEN}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200):

Show headers

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 2400
x-ratelimit-remaining: 2354
vary: Origin


{
    "data": [
        {
            "id": "a04ac243-e47a-4e44-8168-3a9bb5894542",
            "token": "FiWxRa62mrAEc1EXTrtgLTiuHvbcRAkQ",
            "email": "share@lektri.co",
            "status": "PENDING",
            "type": "SHARE",
            "owner_id": "a04ac243-d20e-4453-89f3-5e4de4b83338",
            "expires_at": "2025-11-07T11:44:32.000000Z",
            "created_at": "2025-11-06T11:44:32.000000Z",
            "updated_at": "2025-11-06T11:44:32.000000Z",
            "device_type": "App\\Models\\Charger",
            "device_id": "a04ac243-e1d7-4ced-a2a3-f56974953a88",
            "device_serial": "500413",
            "owner": {
                "id": "a04ac243-d20e-4453-89f3-5e4de4b83338",
                "email": "docs@lektri.co",
                "full_name": "Docs User",
                "first_name": "Docs",
                "last_name": "User"
            },
            "accept_url": "https://cloud.lektri.co/api/v1/invites/FiWxRa62mrAEc1EXTrtgLTiuHvbcRAkQ/accept",
            "reject_url": "https://cloud.lektri.co/api/v1/invites/FiWxRa62mrAEc1EXTrtgLTiuHvbcRAkQ/reject"
        }
    ],
    "success": true,
    "message": "All ok",
    "reference": "None"
}

Received response:

Request failed with error:

Delete onwership invite

requires authentication

Example request:

curl --request DELETE \
    "https://cloud.lektri.co/api/v1/ownership/quia/delete" \
    --header "Authorization: Bearer {TOKEN}"

const url = new URL(
    "https://cloud.lektri.co/api/v1/ownership/quia/delete"
);

const headers = {
    "Authorization": "Bearer {TOKEN}",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

import requests
import json

url = 'https://cloud.lektri.co/api/v1/ownership/quia/delete'
headers = {
  'Authorization': 'Bearer {TOKEN}'
}

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

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://cloud.lektri.co/api/v1/ownership/quia/delete',
    [
        'headers' => [
            'Authorization' => 'Bearer {TOKEN}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (404):

Show headers

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 2400
x-ratelimit-remaining: 2353
vary: Origin


{
    "success": false,
    "message": "Not Found!",
    "reference": "Symfony\\Component\\HttpKernel\\Exception\\NotFoundHttpException",
    "data": null
}

Received response:

Request failed with error:

Accept onwership

requires authentication

Example request:

curl --request GET \
    --get "https://cloud.lektri.co/api/v1/ownership/sunt/accept" \
    --header "Authorization: Bearer {TOKEN}"

const url = new URL(
    "https://cloud.lektri.co/api/v1/ownership/sunt/accept"
);

const headers = {
    "Authorization": "Bearer {TOKEN}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

import requests
import json

url = 'https://cloud.lektri.co/api/v1/ownership/sunt/accept'
headers = {
  'Authorization': 'Bearer {TOKEN}'
}

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://cloud.lektri.co/api/v1/ownership/sunt/accept',
    [
        'headers' => [
            'Authorization' => 'Bearer {TOKEN}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (404):

Show headers

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 2400
x-ratelimit-remaining: 2351
vary: Origin


{
    "success": false,
    "message": "Not Found!",
    "reference": "Symfony\\Component\\HttpKernel\\Exception\\NotFoundHttpException",
    "data": null
}

Received response:

Request failed with error:

Reject onwership

requires authentication

Example request:

curl --request GET \
    --get "https://cloud.lektri.co/api/v1/ownership/non/reject" \
    --header "Authorization: Bearer {TOKEN}"

const url = new URL(
    "https://cloud.lektri.co/api/v1/ownership/non/reject"
);

const headers = {
    "Authorization": "Bearer {TOKEN}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

import requests
import json

url = 'https://cloud.lektri.co/api/v1/ownership/non/reject'
headers = {
  'Authorization': 'Bearer {TOKEN}'
}

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://cloud.lektri.co/api/v1/ownership/non/reject',
    [
        'headers' => [
            'Authorization' => 'Bearer {TOKEN}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (404):

Show headers

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 2400
x-ratelimit-remaining: 2349
vary: Origin


{
    "success": false,
    "message": "Not Found!",
    "reference": "Symfony\\Component\\HttpKernel\\Exception\\NotFoundHttpException",
    "data": null
}

Received response:

Request failed with error:

Meter

Get specific meter

requires authentication

Example request:

curl --request GET \
    --get "https://cloud.lektri.co/api/v1/meters/800311" \
    --header "Authorization: Bearer {TOKEN}"

const url = new URL(
    "https://cloud.lektri.co/api/v1/meters/800311"
);

const headers = {
    "Authorization": "Bearer {TOKEN}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

import requests
import json

url = 'https://cloud.lektri.co/api/v1/meters/800311'
headers = {
  'Authorization': 'Bearer {TOKEN}'
}

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://cloud.lektri.co/api/v1/meters/800311',
    [
        'headers' => [
            'Authorization' => 'Bearer {TOKEN}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (404):

Show headers

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 2400
x-ratelimit-remaining: 2379
vary: Origin


{
    "success": false,
    "message": "Not Found!",
    "reference": "Symfony\\Component\\HttpKernel\\Exception\\NotFoundHttpException",
    "data": null
}

Received response:

Request failed with error:

Register new meter

requires authentication

Example request:

curl --request POST \
    "https://cloud.lektri.co/api/v1/meters" \
    --header "Authorization: Bearer {TOKEN}" \
    --header "Content-Type: application/json" \
    --data "{
    \"model\": \"placeat\",
    \"serial\": \"198750\",
    \"station_name\": \"laboriosam\",
    \"lat\": 42.08323,
    \"lng\": 16,
    \"current\": 162056367.81,
    \"gmt_offset\": 63.74947
}"

const url = new URL(
    "https://cloud.lektri.co/api/v1/meters"
);

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

let body = {
    "model": "placeat",
    "serial": "198750",
    "station_name": "laboriosam",
    "lat": 42.08323,
    "lng": 16,
    "current": 162056367.81,
    "gmt_offset": 63.74947
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

import requests
import json

url = 'https://cloud.lektri.co/api/v1/meters'
payload = {
    "model": "placeat",
    "serial": "198750",
    "station_name": "laboriosam",
    "lat": 42.08323,
    "lng": 16,
    "current": 162056367.81,
    "gmt_offset": 63.74947
}
headers = {
  'Authorization': 'Bearer {TOKEN}',
  'Content-Type': 'application/json'
}

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

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://cloud.lektri.co/api/v1/meters',
    [
        'headers' => [
            'Authorization' => 'Bearer {TOKEN}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'model' => 'placeat',
            'serial' => '198750',
            'station_name' => 'laboriosam',
            'lat' => 42.08323,
            'lng' => 16.0,
            'current' => 162056367.81,
            'gmt_offset' => 63.74947,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (404):

Show headers

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 2400
x-ratelimit-remaining: 2378
vary: Origin


{
    "success": false,
    "message": "Charger not found!",
    "reference": "None",
    "data": null
}

Received response:

Request failed with error:

Request

POST api/v1/meters

Headers

Authorization

Example: Bearer {TOKEN}

Content-Type

Example: application/json

Body Parameters

model string

Example: placeat

serial string

Must be 6 digits. Example: 198750

station_name string

Example: laboriosam

lat number

Example: 42.08323

lng number

Example: 16

current number

Example: 162056367.81

gmt_offset number optional

Example: 63.74947

Update meter

requires authentication

Example request:

curl --request PATCH \
    "https://cloud.lektri.co/api/v1/meters/a04ac243-e173-401f-ab2c-c30014f734af" \
    --header "Authorization: Bearer {TOKEN}" \
    --header "Content-Type: application/json" \
    --data "{
    \"model\": \"dignissimos\",
    \"serial\": \"740675\",
    \"station_name\": \"non\",
    \"current\": 311,
    \"gmt_offset\": 23
}"

const url = new URL(
    "https://cloud.lektri.co/api/v1/meters/a04ac243-e173-401f-ab2c-c30014f734af"
);

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

let body = {
    "model": "dignissimos",
    "serial": "740675",
    "station_name": "non",
    "current": 311,
    "gmt_offset": 23
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

import requests
import json

url = 'https://cloud.lektri.co/api/v1/meters/a04ac243-e173-401f-ab2c-c30014f734af'
payload = {
    "model": "dignissimos",
    "serial": "740675",
    "station_name": "non",
    "current": 311,
    "gmt_offset": 23
}
headers = {
  'Authorization': 'Bearer {TOKEN}',
  'Content-Type': 'application/json'
}

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

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'https://cloud.lektri.co/api/v1/meters/a04ac243-e173-401f-ab2c-c30014f734af',
    [
        'headers' => [
            'Authorization' => 'Bearer {TOKEN}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'model' => 'dignissimos',
            'serial' => '740675',
            'station_name' => 'non',
            'current' => 311.0,
            'gmt_offset' => 23.0,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (404):

Show headers

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 2400
x-ratelimit-remaining: 2377
vary: Origin


{
    "success": false,
    "message": "Not Found!",
    "reference": "Symfony\\Component\\HttpKernel\\Exception\\NotFoundHttpException",
    "data": null
}

Received response:

Request failed with error:

Request

PATCH api/v1/meters/{meter_serial}

Headers

Authorization

Example: Bearer {TOKEN}

Content-Type

Example: application/json

URL Parameters

meter_serial string

Example: a04ac243-e173-401f-ab2c-c30014f734af

Body Parameters

model string

Example: dignissimos

serial string

Must be 6 digits. Example: 740675

station_name string

Example: non

current number

Example: 311

gmt_offset number optional

Example: 23

Unregister meter

requires authentication

Example request:

curl --request DELETE \
    "https://cloud.lektri.co/api/v1/meters/a04ac243-e173-401f-ab2c-c30014f734af" \
    --header "Authorization: Bearer {TOKEN}"

const url = new URL(
    "https://cloud.lektri.co/api/v1/meters/a04ac243-e173-401f-ab2c-c30014f734af"
);

const headers = {
    "Authorization": "Bearer {TOKEN}",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

import requests
import json

url = 'https://cloud.lektri.co/api/v1/meters/a04ac243-e173-401f-ab2c-c30014f734af'
headers = {
  'Authorization': 'Bearer {TOKEN}'
}

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

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://cloud.lektri.co/api/v1/meters/a04ac243-e173-401f-ab2c-c30014f734af',
    [
        'headers' => [
            'Authorization' => 'Bearer {TOKEN}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (404):

Show headers

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 2400
x-ratelimit-remaining: 2376
vary: Origin


{
    "success": false,
    "message": "Not Found!",
    "reference": "Symfony\\Component\\HttpKernel\\Exception\\NotFoundHttpException",
    "data": null
}

Received response:

Request failed with error:

Services

Adjust dynamic current.

requires authentication

Example request:

curl --request PATCH \
    "https://cloud.lektri.co/api/v1/services/service/chargers/500413/current" \
    --header "Authorization: Bearer {TOKEN}" \
    --header "Content-Type: application/json" \
    --data "{
    \"dynamic_current\": \"12\"
}"

const url = new URL(
    "https://cloud.lektri.co/api/v1/services/service/chargers/500413/current"
);

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

let body = {
    "dynamic_current": "12"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

import requests
import json

url = 'https://cloud.lektri.co/api/v1/services/service/chargers/500413/current'
payload = {
    "dynamic_current": "12"
}
headers = {
  'Authorization': 'Bearer {TOKEN}',
  'Content-Type': 'application/json'
}

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

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'https://cloud.lektri.co/api/v1/services/service/chargers/500413/current',
    [
        'headers' => [
            'Authorization' => 'Bearer {TOKEN}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'dynamic_current' => '12',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200):


{
    "success": true,
    "message": "OK",
    "data": true
}

Received response:

Request failed with error:

Request

PATCH api/v1/services/{service}/chargers/{charger_serial}/current

Headers

Authorization

Example: Bearer {TOKEN}

Content-Type

Example: application/json

URL Parameters

service string

Service name Example: service

charger_serial integer

Charger serial number Example: 500413

Body Parameters

dynamic_current required optional

Command int Example: 12

Get a list of stations with signup chargers

requires authentication

Example request:

curl --request GET \
    --get "https://cloud.lektri.co/api/v1/services/service/list" \
    --header "Authorization: Bearer {TOKEN}"

const url = new URL(
    "https://cloud.lektri.co/api/v1/services/service/list"
);

const headers = {
    "Authorization": "Bearer {TOKEN}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

import requests
import json

url = 'https://cloud.lektri.co/api/v1/services/service/list'
headers = {
  'Authorization': 'Bearer {TOKEN}'
}

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://cloud.lektri.co/api/v1/services/service/list',
    [
        'headers' => [
            'Authorization' => 'Bearer {TOKEN}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200):


{
    "data": [
        {
            "id": "9d7e7b6e-9f20-4cb9-b749-5406ea8572ae",
            "meter_id": "123456789",
            "chargers": [
                {
                    "id": "9d7e7b6e-a02e-4eb6-8841-8f23ea8c588a",
                    "serial": "50001",
                    "model": "1P7K",
                    "instant_power": 22,
                    "updated_at": "2024-11-28T14:23:30.091Z"
                },
            ]
        }
    ],
    "links": {
        "first": "https://cloud.lektri.co/api/v1/services/service/list?page=1",
        "last": "https://cloud.lektri.co/api/v1/services/service/list?page=1",
        "prev": null,
        "next": null
    },
    "meta": {
        "current_page": 1,
        "from": 1,
        "last_page": 1,
        "links": [
            {
                "url": null,
                "label": "&laquo; Previous",
                "active": false
            },
            {
                "url": "https://cloud.lektri.co/api/v1/services/service/list?page=1",
                "label": "1",
                "active": true
            },
            {
                "url": null,
                "label": "Next &raquo;",
                "active": false
            }
        ],
        "path": "https://cloud.lektri.co/api/v1/services/service/list",
        "per_page": 15,
        "to": 1,
        "total": 1
    },
    "success": true,
    "message": "All ok",
    "reference": "None"
}

Received response:

Request failed with error:

Get latest charger details.

requires authentication

Example request:

curl --request GET \
    --get "https://cloud.lektri.co/api/v1/services/service/chargers/500413/details" \
    --header "Authorization: Bearer {TOKEN}"

const url = new URL(
    "https://cloud.lektri.co/api/v1/services/service/chargers/500413/details"
);

const headers = {
    "Authorization": "Bearer {TOKEN}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

import requests
import json

url = 'https://cloud.lektri.co/api/v1/services/service/chargers/500413/details'
headers = {
  'Authorization': 'Bearer {TOKEN}'
}

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://cloud.lektri.co/api/v1/services/service/chargers/500413/details',
    [
        'headers' => [
            'Authorization' => 'Bearer {TOKEN}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200):


{
    "success": true,
    "message": "All ok",
    "reference": "500001",
    "data": {
        "updated_at": "2024-11-28T14:23:30.091Z",
        "state": "B_AUTH",
        "energy_index": 0,
        "total_charged_energy": 0,
        "install_current": 8,
        "charger_is_paused": false,
        "session_energy": 0,
        "charging_time": 0,
        "instant_power": 0,
        "voltages": [
            222.47,
            0,
            0
        ],
        "currents": [
            0,
            0,
            0
        ]
    }
}

Received response:

Request failed with error:

Request

GET api/v1/services/{service}/chargers/{charger_serial}/details

Headers

Authorization

Example: Bearer {TOKEN}

URL Parameters

service string

Service name Example: service

charger_serial integer

Charger serial number Example: 500413

Get a list of session for each charger

requires authentication

Example request:

curl --request GET \
    --get "https://cloud.lektri.co/api/v1/services/service/chargers/a04ac243-e1d7-4ced-a2a3-f56974953a88/history" \
    --header "Authorization: Bearer {TOKEN}"

const url = new URL(
    "https://cloud.lektri.co/api/v1/services/service/chargers/a04ac243-e1d7-4ced-a2a3-f56974953a88/history"
);

const headers = {
    "Authorization": "Bearer {TOKEN}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

import requests
import json

url = 'https://cloud.lektri.co/api/v1/services/service/chargers/a04ac243-e1d7-4ced-a2a3-f56974953a88/history'
headers = {
  'Authorization': 'Bearer {TOKEN}'
}

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://cloud.lektri.co/api/v1/services/service/chargers/a04ac243-e1d7-4ced-a2a3-f56974953a88/history',
    [
        'headers' => [
            'Authorization' => 'Bearer {TOKEN}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200):


{
    "data": [
        {
            "id": "ffeb1d05-8c5c-42e9-a690-007fca57216f",
            "charger": "500001",
            "created_at": "2024-11-18T12:16:35.000000Z",
            "updated_at": "2024-11-29T09:44:56.000000Z",
            "charge_time": 15282,
            "duration": "4 hours 14 minutes 42 seconds",
            "energy": 21330,
            "green_energy": 785,
            "data": {
                "timestamps": [
                    "02:01:21",
                    "02:00:52"
                ],
                "grid_power": [
                    1203,
                    3203
                ],
                "green_power": [
                    345,
                    123
                ],
                "instant_power": [
                    789,
                    1058
                ]
            }
        }
    ],
    "links": {
        "first": "https://cloud.lektri.co/api/v1/services/service/chargers/500413/history?page=1",
        "last": "https://cloud.lektri.co/api/v1/services/service/chargers/500413/history?page=1",
        "prev": null,
        "next": null
    },
    "meta": {
        "current_page": 1,
        "from": 1,
        "last_page": 1,
        "links": [
            {
                "url": null,
                "label": "&laquo; Previous",
                "active": false
            },
            {
                "url": "https://cloud.lektri.co/api/v1/services/service/chargers/500413/history?page=1",
                "label": "1",
                "active": true
            },
            {
                "url": null,
                "label": "Next &raquo;",
                "active": false
            }
        ],
        "path": "https://cloud.lektri.co/api/v1/services/service/chargers/500413/history",
        "per_page": 15,
        "to": 2,
        "total": 2
    },
    "success": true,
    "message": "All ok",
    "reference": "None"
}

Received response:

Request failed with error:

Request

GET api/v1/services/{service}/chargers/{charger_serial}/history

Headers

Authorization

Example: Bearer {TOKEN}

URL Parameters

service string

Service name Example: service

charger_serial string

Example: a04ac243-e1d7-4ced-a2a3-f56974953a88

Station

@urlParam station_id string required Station id Example: 99037b42-7d49-446e-8403-f7ae6c8c8052

Get stations list

requires authentication

Example request:

curl --request GET \
    --get "https://cloud.lektri.co/api/v1/stations" \
    --header "Authorization: Bearer {TOKEN}"

const url = new URL(
    "https://cloud.lektri.co/api/v1/stations"
);

const headers = {
    "Authorization": "Bearer {TOKEN}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

import requests
import json

url = 'https://cloud.lektri.co/api/v1/stations'
headers = {
  'Authorization': 'Bearer {TOKEN}'
}

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://cloud.lektri.co/api/v1/stations',
    [
        'headers' => [
            'Authorization' => 'Bearer {TOKEN}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200):

Show headers

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 2400
x-ratelimit-remaining: 2345
vary: Origin


{
    "success": true,
    "message": "All ok",
    "reference": "None",
    "data": {
        "stations": [
            {
                "id": "a04ac243-dbbe-4f4c-b390-31b2f8e65a2f",
                "name": "Lewis Strosin Jr.",
                "lat": "45.7573346",
                "lng": "21.2236252",
                "country": "RO",
                "currency": "RON",
                "export_price": null,
                "provider": null,
                "is_default": false,
                "main": null,
                "owner": null,
                "enable_tariffs": 0,
                "chargers": [
                    {
                        "id": "a04ac243-e1d7-4ced-a2a3-f56974953a88",
                        "serial": "500413",
                        "name": "Charger 529356",
                        "model": "1P7K",
                        "status": "UNKNOWN",
                        "status_extended": null,
                        "limit": "HARDWARE",
                        "gmt_offset": 2,
                        "meta": {
                            "extended_charger_state": null,
                            "config": [],
                            "boot": [],
                            "notify": []
                        },
                        "lat": 45.1234,
                        "lng": 23.1234,
                        "country": "RO",
                        "auth": 0,
                        "ip": "192.168.0.1",
                        "em": 0,
                        "owner_id": "a04ac243-d20e-4453-89f3-5e4de4b83338",
                        "schedule": 0,
                        "led": 100,
                        "user_current": 16,
                        "install_current": 32,
                        "pwm_mode": 0,
                        "firmware": "1.40",
                        "ocpp_server_link": "ws://ocpp.lektri.co",
                        "phase": 1,
                        "type": "PRIVATE",
                        "topic": "1p7k_529356",
                        "network": "DISCONNECTED",
                        "status_at": "2025-11-06 13:44:32",
                        "connected": true,
                        "is_shared": false,
                        "owner": {
                            "id": "a04ac243-d20e-4453-89f3-5e4de4b83338",
                            "email": "docs@lektri.co",
                            "name": "Docs User",
                            "full_name": "Docs User",
                            "tag": "0GOUwD9Dzl"
                        },
                        "users": [],
                        "station": {
                            "id": "a04ac243-dbbe-4f4c-b390-31b2f8e65a2f",
                            "name": "Lewis Strosin Jr.",
                            "lat": "45.7573346",
                            "lng": "21.2236252",
                            "is_default": false
                        },
                        "integrations": [],
                        "is_default": false
                    }
                ],
                "meters": [
                    {
                        "id": "a04ac243-e173-401f-ab2c-c30014f734af",
                        "auth": 0,
                        "name": "Caroline Heidenreich PhD",
                        "serial": "816660",
                        "model": "EM",
                        "type": "UNASSIGNED",
                        "grid": "THREEPHASE",
                        "network": "DISCONNECTED",
                        "meta": {
                            "voltage_1": 235,
                            "voltage_2": 235.7,
                            "voltage_3": 229.3,
                            "current_1": 0,
                            "current_2": 0.01,
                            "current_3": 0,
                            "power_1": 0,
                            "power_2": 0,
                            "power_3": 0,
                            "power_total": 0,
                            "energy_1": 0,
                            "energy_2": 243.14,
                            "energy_3": 2.21,
                            "energy_total": 245.35
                        },
                        "topic": "m2w_816660",
                        "firmware": "1.13",
                        "ota_policy": "MANAGED",
                        "ota_version": null,
                        "ocpp_server_link": null,
                        "station_id": "a04ac243-dbbe-4f4c-b390-31b2f8e65a2f",
                        "owner_id": "a04ac243-d20e-4453-89f3-5e4de4b83338",
                        "installer_id": null,
                        "status_at": "2025-11-06T11:44:32.000000Z",
                        "gmt_offset": 2,
                        "platform": "esp8266",
                        "load_balancing_mode": 1,
                        "breaker_rating": 33,
                        "reverse_current": 1,
                        "ip": "192.168.0.1",
                        "batch_run": 1,
                        "batch_attempts": 0,
                        "created_at": "2025-11-06T11:44:32.000000Z",
                        "updated_at": "2025-11-06T11:44:32.000000Z",
                        "retired_at": null,
                        "retired_reason": null,
                        "owner": {
                            "id": "a04ac243-d20e-4453-89f3-5e4de4b83338",
                            "email": "docs@lektri.co",
                            "name": "Docs User",
                            "full_name": "Docs User",
                            "tag": "0GOUwD9Dzl"
                        },
                        "is_default": false
                    }
                ],
                "tariffs": []
            }
        ],
        "unassigned": {
            "chargers": [],
            "meters": []
        }
    }
}

Received response:

Request failed with error:

Get specific station

requires authentication

Example request:

curl --request GET \
    --get "https://cloud.lektri.co/api/v1/stations/99889935-cb0e-41de-9d7a-3749e66c8b49" \
    --header "Authorization: Bearer {TOKEN}"

const url = new URL(
    "https://cloud.lektri.co/api/v1/stations/99889935-cb0e-41de-9d7a-3749e66c8b49"
);

const headers = {
    "Authorization": "Bearer {TOKEN}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

import requests
import json

url = 'https://cloud.lektri.co/api/v1/stations/99889935-cb0e-41de-9d7a-3749e66c8b49'
headers = {
  'Authorization': 'Bearer {TOKEN}'
}

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

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://cloud.lektri.co/api/v1/stations/99889935-cb0e-41de-9d7a-3749e66c8b49',
    [
        'headers' => [
            'Authorization' => 'Bearer {TOKEN}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200):

Show headers

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 2400
x-ratelimit-remaining: 2344
vary: Origin


{
    "success": false,
    "message": "Station not found!",
    "reference": "None",
    "data": null
}

Received response:

Request failed with error:

Register new station

requires authentication

Example request:

curl --request POST \
    "https://cloud.lektri.co/api/v1/stations" \
    --header "Authorization: Bearer {TOKEN}" \
    --header "Content-Type: application/json" \
    --data "{
    \"name\": \"et\",
    \"lat\": -89,
    \"lng\": -180,
    \"current\": 13737324.6691
}"

const url = new URL(
    "https://cloud.lektri.co/api/v1/stations"
);

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

let body = {
    "name": "et",
    "lat": -89,
    "lng": -180,
    "current": 13737324.6691
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

import requests
import json

url = 'https://cloud.lektri.co/api/v1/stations'
payload = {
    "name": "et",
    "lat": -89,
    "lng": -180,
    "current": 13737324.6691
}
headers = {
  'Authorization': 'Bearer {TOKEN}',
  'Content-Type': 'application/json'
}

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

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://cloud.lektri.co/api/v1/stations',
    [
        'headers' => [
            'Authorization' => 'Bearer {TOKEN}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'name' => 'et',
            'lat' => -89,
            'lng' => -180,
            'current' => 13737324.6691,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200):

Show headers

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 2400
x-ratelimit-remaining: 2343
vary: Origin


{
    "success": true,
    "message": "All ok",
    "reference": "None",
    "data": {
        "id": "a04ac246-0b19-4d9c-a26b-286c4c360176",
        "name": "et",
        "lat": -89,
        "lng": -180,
        "country": null,
        "currency": null,
        "export_price": null,
        "provider": null,
        "is_default": false,
        "main": null,
        "owner": {
            "id": "a04ac243-d20e-4453-89f3-5e4de4b83338",
            "email": "docs@lektri.co",
            "name": "Docs User",
            "full_name": "Docs User",
            "tag": "0GOUwD9Dzl"
        },
        "enable_tariffs": null,
        "chargers": [],
        "meters": [],
        "tariffs": []
    }
}

Received response:

Request failed with error:

Request

POST api/v1/stations

Headers

Authorization

Example: Bearer {TOKEN}

Content-Type

Example: application/json

Body Parameters

name string

Example: et

lat number optional

Must be between -90 and 90. Example: -89

lng number optional

Must be between -180 and 180. Example: -180

current number optional

Example: 13737324.6691

Update station

requires authentication

Example request:

curl --request PATCH \
    "https://cloud.lektri.co/api/v1/stations/a04ac243-dbbe-4f4c-b390-31b2f8e65a2f" \
    --header "Authorization: Bearer {TOKEN}" \
    --header "Content-Type: application/json" \
    --data "{
    \"name\": \"illo\",
    \"lat\": -89,
    \"lng\": -180,
    \"enable_tariffs\": true,
    \"export_price\": 14367733.6955648,
    \"country\": \"autem\",
    \"currency\": \"dignissimos\",
    \"provider_id\": \"est\",
    \"current\": 387607880.998,
    \"main\": \"aut\"
}"

const url = new URL(
    "https://cloud.lektri.co/api/v1/stations/a04ac243-dbbe-4f4c-b390-31b2f8e65a2f"
);

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

let body = {
    "name": "illo",
    "lat": -89,
    "lng": -180,
    "enable_tariffs": true,
    "export_price": 14367733.6955648,
    "country": "autem",
    "currency": "dignissimos",
    "provider_id": "est",
    "current": 387607880.998,
    "main": "aut"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

import requests
import json

url = 'https://cloud.lektri.co/api/v1/stations/a04ac243-dbbe-4f4c-b390-31b2f8e65a2f'
payload = {
    "name": "illo",
    "lat": -89,
    "lng": -180,
    "enable_tariffs": true,
    "export_price": 14367733.6955648,
    "country": "autem",
    "currency": "dignissimos",
    "provider_id": "est",
    "current": 387607880.998,
    "main": "aut"
}
headers = {
  'Authorization': 'Bearer {TOKEN}',
  'Content-Type': 'application/json'
}

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

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'https://cloud.lektri.co/api/v1/stations/a04ac243-dbbe-4f4c-b390-31b2f8e65a2f',
    [
        'headers' => [
            'Authorization' => 'Bearer {TOKEN}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'name' => 'illo',
            'lat' => -89,
            'lng' => -180,
            'enable_tariffs' => true,
            'export_price' => 14367733.6955648,
            'country' => 'autem',
            'currency' => 'dignissimos',
            'provider_id' => 'est',
            'current' => 387607880.998,
            'main' => 'aut',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 2400
x-ratelimit-remaining: 2342
vary: Origin


{
    "success": false,
    "message": "This action is unauthorized.",
    "reference": "Symfony\\Component\\HttpKernel\\Exception\\AccessDeniedHttpException",
    "data": null
}

Received response:

Request failed with error:

Request

PATCH api/v1/stations/{station_id}

Headers

Authorization

Example: Bearer {TOKEN}

Content-Type

Example: application/json

URL Parameters

station_id string

The ID of the station. Example: a04ac243-dbbe-4f4c-b390-31b2f8e65a2f

Body Parameters

name string optional

Example: illo

lat number optional

Must be between -90 and 90. Example: -89

lng number optional

Must be between -180 and 180. Example: -180

enable_tariffs boolean optional true false

Example: true

export_price number optional

Example: 14367733.695565

country string optional

Example: autem

currency string optional

Example: dignissimos

provider_id string optional

The id of an existing record in the providers table. Example: est

current number optional

Example: 387607880.998

main string optional

Example: aut

Remove station

requires authentication

Example request:

curl --request DELETE \
    "https://cloud.lektri.co/api/v1/stations/a04ac243-dbbe-4f4c-b390-31b2f8e65a2f" \
    --header "Authorization: Bearer {TOKEN}"

const url = new URL(
    "https://cloud.lektri.co/api/v1/stations/a04ac243-dbbe-4f4c-b390-31b2f8e65a2f"
);

const headers = {
    "Authorization": "Bearer {TOKEN}",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

import requests
import json

url = 'https://cloud.lektri.co/api/v1/stations/a04ac243-dbbe-4f4c-b390-31b2f8e65a2f'
headers = {
  'Authorization': 'Bearer {TOKEN}'
}

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

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://cloud.lektri.co/api/v1/stations/a04ac243-dbbe-4f4c-b390-31b2f8e65a2f',
    [
        'headers' => [
            'Authorization' => 'Bearer {TOKEN}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 2400
x-ratelimit-remaining: 2341
vary: Origin


{
    "success": false,
    "message": "This action is unauthorized.",
    "reference": "Symfony\\Component\\HttpKernel\\Exception\\AccessDeniedHttpException",
    "data": null
}

Received response:

Request failed with error:

Introduction

Simple authentication using Bearer tokens

Connecting to the API using client credentials

Requesting Tokens

Approving the Request

Converting Authorization Codes to Access Tokens

Refreshing Tokens

User management

Login a user.

Request Try it out Cancel Send Request

Headers

Body Parameters

Create a new user

Request Try it out Cancel Send Request

Headers

Body Parameters

Logout current user.

Request Try it out Cancel Send Request

Headers

Get the current authenticated user.

Request Try it out Cancel Send Request

Headers

Updates current user.

Request Try it out Cancel Send Request

Headers

Body Parameters

Send feedback.

Request Try it out Cancel Send Request

Headers

Body Parameters

Get the impersonated user authenticated token.

Request Try it out Cancel Send Request

Headers

URL Parameters

Assets

Get user's assets

Request Try it out Cancel Send Request

Headers

Get user's assets

Request Try it out Cancel Send Request

Headers

Onboard

Assign an device to a user

Request Try it out Cancel Send Request

Headers

URL Parameters

Body Parameters

Offboard a device

Request Try it out Cancel Send Request

Headers

URL Parameters

Sessions

Get all sessions

Request Try it out Cancel Send Request

Headers

Body Parameters

Get all sessions extra

Request Try it out Cancel Send Request

Headers

Body Parameters

Get specific sessions

Request Try it out Cancel Send Request

Headers

URL Parameters

Get specific sessions extra

Request Try it out Cancel Send Request

Headers

URL Parameters

Get all sessions

Request Try it out Cancel Send Request

Headers

Body Parameters

Get all sessions

Request Try it out Cancel Send Request

Headers

Body Parameters

Interactions

Send command to charger

Request Try it out Cancel Send Request

Headers

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request