MENU navbar-image

Introduction

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

Base URL

https://api.nomeo.com

Authenticating requests

This API is authenticated by sending an Authorization header with the value "Bearer {YOUR_AUTH_KEY}".

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

We will provide API token key for approved partners.

Clients

Clients APIs

Get list clients

requires authentication

Example request:
curl --request GET \
    --get "https://api.nomeo.com/clients?keyword=test" \
    --header "Authorization: Bearer API_KEY" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.nomeo.com/clients"
);

const params = {
    "keyword": "test",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

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

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

url = 'https://api.nomeo.com/clients'
params = {
  'keyword': 'test',
}
headers = {
  'Authorization': 'Bearer API_KEY',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200):


{
    "success": true,
    "message": "List clients",
    "data": [
        {
            "id": "1",
            "firstname": "Joe",
            "lastname": "Bin",
            "company": "",
            "address1": "Address 1",
            "address2": "",
            "city": "CT",
            "postcode": "8840",
            "country": "BE",
            "phone": "111111111",
            "email": "mail@domain.be",
            "client_type": "Managed Client",
            "vat_number": ""
        }
    ],
    "customData": []
}

Request   

GET clients

Query Parameters

keyword  string optional  

Filter string on (part of) firstname, lastname, companyname.

Add client

requires authentication

Example request:
curl --request POST \
    "https://api.nomeo.com/clients/add" \
    --header "Authorization: Bearer API_KEY" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"firstname\": \"Joe\",
    \"lastname\": \"Bin\",
    \"company\": \"Google\",
    \"password\": \"Pass!123\",
    \"postcode\": 1234,
    \"address1\": \"Address 1\",
    \"address2\": \"Address 2\",
    \"city\": \"Test\",
    \"country\": \"BE\",
    \"email\": \"info@domain.be\",
    \"phone\": 123456789,
    \"client_type\": \"Managed Client\",
    \"vat_number\": \"123456789\"
}"

const url = new URL(
    "https://api.nomeo.com/clients/add"
);

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

let body = {
    "firstname": "Joe",
    "lastname": "Bin",
    "company": "Google",
    "password": "Pass!123",
    "postcode": 1234,
    "address1": "Address 1",
    "address2": "Address 2",
    "city": "Test",
    "country": "BE",
    "email": "info@domain.be",
    "phone": 123456789,
    "client_type": "Managed Client",
    "vat_number": "123456789"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://api.nomeo.com/clients/add',
    [
        'headers' => [
            'Authorization' => 'Bearer API_KEY',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'firstname' => 'Joe',
            'lastname' => 'Bin',
            'company' => 'Google',
            'password' => 'Pass!123',
            'postcode' => 1234.0,
            'address1' => 'Address 1',
            'address2' => 'Address 2',
            'city' => 'Test',
            'country' => 'BE',
            'email' => 'info@domain.be',
            'phone' => 123456789.0,
            'client_type' => 'Managed Client',
            'vat_number' => '123456789',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.nomeo.com/clients/add'
payload = {
    "firstname": "Joe",
    "lastname": "Bin",
    "company": "Google",
    "password": "Pass!123",
    "postcode": 1234,
    "address1": "Address 1",
    "address2": "Address 2",
    "city": "Test",
    "country": "BE",
    "email": "info@domain.be",
    "phone": 123456789,
    "client_type": "Managed Client",
    "vat_number": "123456789"
}
headers = {
  'Authorization': 'Bearer API_KEY',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200):


{
    "success": true,
    "message": "Added Client",
    "data": [
        {
            "id": 11287,
            "firstname": "test",
            "lastname": "test2",
            "company": "MS",
            "address1": "test add 1",
            "address2": "",
            "city": "London",
            "postcode": "134",
            "country": "BE",
            "phone": "222222",
            "email": "testdomain7@test.be",
            "client_type": "Managed Client",
            "vat_number": "111"
        }
    ],
    "customData": []
}

Request   

POST clients/add

Body Parameters

firstname  string  

First name, Number of chars between 1-100.

lastname  string  

Last name, Number of chars between 1-100.

company  string optional  

Company name, Number of chars between 1-100.

password  string  

Password, Number of chars between 6-100.
The password contains characters from at least three of the following five categories:
(1) English uppercase characters (A – Z)
(2) English lowercase characters (a – z)
(3) Base 10 digits (0 – 9)
(4) Non-alphanumeric (For example: !, $, #, or %)
(5) Unicode characters.

postcode  number  

Post code, must be entirely alpha-numeric characters. Number of chars between 1-100.

address1  string  

Address 1, Number of chars between 1-100.

address2  string optional  

Address 2, Number of chars between 1-100.

city  string  

City name, Number of chars between 1-100.

country  string  

2 characters ISO country code, Upper case, Reference: https://en.wikipedia.org/wiki/List_of_ISO_3166_country_codes.

email  string  

Email, Number of chars between 5-100.

phone  number  

Phone, Number of chars between 5-25.

client_type  string  

Client type.
Available options: "Managed Client", "Self Servicing Client".

vat_number  string optional  

Vat number, must be entirely alpha-numeric characters. Number of chars between 3-100.

Update client

requires authentication

Example request:
curl --request PUT \
    "https://api.nomeo.com/clients/1" \
    --header "Authorization: Bearer API_KEY" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"firstname\": \"Joe\",
    \"lastname\": \"Bin\",
    \"company\": \"Google\",
    \"postcode\": 1234,
    \"address1\": \"Address 1\",
    \"address2\": \"Address 2\",
    \"city\": \"Test\",
    \"country\": \"BE\",
    \"email\": \"info@domain.be\",
    \"phone\": 123456789,
    \"vat_number\": \"123456789\"
}"

const url = new URL(
    "https://api.nomeo.com/clients/1"
);

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

let body = {
    "firstname": "Joe",
    "lastname": "Bin",
    "company": "Google",
    "postcode": 1234,
    "address1": "Address 1",
    "address2": "Address 2",
    "city": "Test",
    "country": "BE",
    "email": "info@domain.be",
    "phone": 123456789,
    "vat_number": "123456789"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->put(
    'https://api.nomeo.com/clients/1',
    [
        'headers' => [
            'Authorization' => 'Bearer API_KEY',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'firstname' => 'Joe',
            'lastname' => 'Bin',
            'company' => 'Google',
            'postcode' => 1234.0,
            'address1' => 'Address 1',
            'address2' => 'Address 2',
            'city' => 'Test',
            'country' => 'BE',
            'email' => 'info@domain.be',
            'phone' => 123456789.0,
            'vat_number' => '123456789',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.nomeo.com/clients/1'
payload = {
    "firstname": "Joe",
    "lastname": "Bin",
    "company": "Google",
    "postcode": 1234,
    "address1": "Address 1",
    "address2": "Address 2",
    "city": "Test",
    "country": "BE",
    "email": "info@domain.be",
    "phone": 123456789,
    "vat_number": "123456789"
}
headers = {
  'Authorization': 'Bearer API_KEY',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200):


{
    "success": true,
    "message": "Updated Client",
    "data": [
        {
            "id": 11287,
            "firstname": "test",
            "lastname": "test2",
            "company": "MS",
            "address1": "test add 1",
            "address2": "",
            "city": "London",
            "postcode": "134",
            "country": "BE",
            "phone": "222222",
            "email": "testdomain7@test.be",
            "client_type": "Managed Client",
            "vat_number": "111"
        }
    ],
    "customData": []
}

Request   

PUT clients/{clientId}

URL Parameters

clientId  string  

Client ID.

Body Parameters

firstname  string  

First name, Number of chars between 1-100.

lastname  string  

Last name, Number of chars between 1-100.

company  string optional  

Company name, Number of chars between 1-100.

postcode  number  

Post code, must be entirely alpha-numeric characters. Number of chars between 1-100.

address1  string  

Address 1, Number of chars between 1-100.

address2  string optional  

Address 2, Number of chars between 1-100.

city  string  

City name, Number of chars between 1-100.

country  string  

2 characters ISO country code, Upper case, Reference: https://en.wikipedia.org/wiki/List_of_ISO_3166_country_codes.

email  string  

Email, Number of chars between 5-100.

phone  number  

Phone, Number of chars between 5-25.

vat_number  string optional  

Vat number, must be entirely alpha-numeric characters. Number of chars between 3-100.

Delete client

requires authentication

Example request:
curl --request DELETE \
    "https://api.nomeo.com/clients/1" \
    --header "Authorization: Bearer API_KEY" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.nomeo.com/clients/1"
);

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

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

url = 'https://api.nomeo.com/clients/1'
headers = {
  'Authorization': 'Bearer API_KEY',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200):


{
    "success": true,
    "message": "Deleted Client"
}

Request   

DELETE clients/{clientId}

URL Parameters

clientId  integer  

Client ID.

Domain

Domain APIs

Register domain

requires authentication

Example request:
curl --request POST \
    "https://api.nomeo.com/domains/register" \
    --header "Authorization: Bearer API_KEY" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"testdomain.com\",
    \"period\": 1,
    \"action\": \"register\",
    \"epp_code\": \"123456\",
    \"client_id\": 1,
    \"ns1\": \"ns1.com\",
    \"ns2\": \"ns2.com\",
    \"ns3\": \"ns3.com\",
    \"ns4\": \"ns4.com\"
}"

const url = new URL(
    "https://api.nomeo.com/domains/register"
);

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

let body = {
    "name": "testdomain.com",
    "period": 1,
    "action": "register",
    "epp_code": "123456",
    "client_id": 1,
    "ns1": "ns1.com",
    "ns2": "ns2.com",
    "ns3": "ns3.com",
    "ns4": "ns4.com"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://api.nomeo.com/domains/register',
    [
        'headers' => [
            'Authorization' => 'Bearer API_KEY',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'testdomain.com',
            'period' => 1,
            'action' => 'register',
            'epp_code' => '123456',
            'client_id' => 1,
            'ns1' => 'ns1.com',
            'ns2' => 'ns2.com',
            'ns3' => 'ns3.com',
            'ns4' => 'ns4.com',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.nomeo.com/domains/register'
payload = {
    "name": "testdomain.com",
    "period": 1,
    "action": "register",
    "epp_code": "123456",
    "client_id": 1,
    "ns1": "ns1.com",
    "ns2": "ns2.com",
    "ns3": "ns3.com",
    "ns4": "ns4.com"
}
headers = {
  'Authorization': 'Bearer API_KEY',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (201):


{
    "success": true,
    "message": "Registered successfully",
    "data": {
        "order_id": 28883,
        "domain_id": "26024"
    },
    "customData": []
}

Request   

POST domains/register

Body Parameters

name  string  

Domain name. Number of chars between 3-100.

period  integer  

Number of years, between 1-10.

action  string  

Domain action: "register" or "transfer".

epp_code  string optional  

EPP transfer code. Number of chars between 3-100. Required when action=transfer.

client_id  integer optional  

Client ID. You can get Client id in "Get list clients" API.

ns1  string optional  

Name Server 1. Number of chars between 5-100.

ns2  string optional  

Name Server 2. Number of chars between 5-100.

ns3  string optional  

Name Server 3. Number of chars between 5-100.

ns4  string optional  

Name Server 4. Number of chars between 5-100.

Check the availability of domain

requires authentication

Example request:
curl --request POST \
    "https://api.nomeo.com/domains/check-domain" \
    --header "Authorization: Bearer API_KEY" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"testdomain.com\"
}"

const url = new URL(
    "https://api.nomeo.com/domains/check-domain"
);

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

let body = {
    "name": "testdomain.com"
};

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

url = 'https://api.nomeo.com/domains/check-domain'
payload = {
    "name": "testdomain.com"
}
headers = {
  'Authorization': 'Bearer API_KEY',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200):


{
    "success": true,
    "available": true,
    "message": "domaintest12345.com is available to register!"
}

Request   

POST domains/check-domain

Body Parameters

name  string  

Domain name. Number of chars between 3-100.

Get domains list

requires authentication

Example request:
curl --request GET \
    --get "https://api.nomeo.com/domains/list" \
    --header "Authorization: Bearer API_KEY" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.nomeo.com/domains/list"
);

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

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

url = 'https://api.nomeo.com/domains/list'
headers = {
  'Authorization': 'Bearer API_KEY',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200):


{
    "data": [
        {
            "id": "123",
            "domain": "testdomain.be",
            "domain_name": "testdomain.be",
            "client_id": "123",
            "expire_date": "2020-12-08",
            "expired": true,
            "days_valid": 0,
            "status": "Pending",
            "cancelled_but_not_expired": false,
            "expiring_within_60_days": false,
            "expired_less_than_180_days_ago": false,
            "auto_renew": true,
            "registration_date": "08/12/2020",
            "registered_to": "08/12/2020",
            "registration_period": "1",
            "price": "123.00"
        }
    ]
}

Request   

GET domains/list

Get domain DNS records

requires authentication

Example request:
curl --request GET \
    --get "https://api.nomeo.com/domains/testdomain.com/records" \
    --header "Authorization: Bearer API_KEY" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.nomeo.com/domains/testdomain.com/records"
);

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

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

url = 'https://api.nomeo.com/domains/testdomain.com/records'
headers = {
  'Authorization': 'Bearer API_KEY',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200):


{
    "ResultCode": 200,
    "ResultMessage": "Here is zone 'testdomain.com'",
    "Success": true,
    "Result": {
        "Records": {
            "SOA": [
                {
                    "ChangeDate": 1675390325,
                    "Id": 123,
                    "Priority": 0,
                    "RecordData": "ns1.dns.be hostmaster.dns.be 2023020301 7200 7200 604800 3600",
                    "RecordMetaType": 0,
                    "RecordMetaTypeName": "Regular",
                    "RecordName": "testdomain.be",
                    "RecordType": 10,
                    "RecordTypeName": "SOA",
                    "TTL": 3600,
                    "ZoneId": 123
                }
            ],
            "A": [],
            "AAAA": [],
            "CNAME": [],
            "ANAME": [],
            "MX": [],
            "TXT": [],
            "SRV": [],
            "CAA": [],
            "NS": [],
            "DS": []
        },
        "Zone": {
            "Id": 123,
            "IsMaster": true,
            "IsSecure": false,
            "Master": null,
            "Name": "testdomain.be",
            "NotifiedSerial": "123",
            "NsType": "MASTER",
            "Nsec3Param": null,
            "Subdomains": []
        },
        "Office365HaveRecords": {
            "mx": {
                "mail": false
            },
            "cname": {
                "autodiscover": false,
                "sip": false,
                "lyncdiscover": false,
                "msoid": false,
                "enterpriseregistration": false,
                "enterpriseenrollment": false
            },
            "txt": {
                "spf": false
            },
            "srv": {
                "sip": false,
                "sipfederationtls": false
            }
        },
        "GoogleHaveRecords": {
            "mx": {
                "aspmx": false,
                "alt1": false,
                "alt2": false,
                "alt3": false,
                "alt4": false
            },
            "txt": {
                "spf": false
            }
        }
    }
}

Request   

GET domains/{domain}/records

URL Parameters

domain  string  

Domain name.

Create domain DNS record

requires authentication

Example request:
curl --request POST \
    "https://api.nomeo.com/domains/testdomain.com/record" \
    --header "Authorization: Bearer API_KEY" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"record_type_name\": \"A\",
    \"record_name\": \"test\",
    \"record_data\": \"1.2.3.4\",
    \"priority\": 1,
    \"fallback_ip\": \"1.2.3.4\"
}"

const url = new URL(
    "https://api.nomeo.com/domains/testdomain.com/record"
);

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

let body = {
    "record_type_name": "A",
    "record_name": "test",
    "record_data": "1.2.3.4",
    "priority": 1,
    "fallback_ip": "1.2.3.4"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://api.nomeo.com/domains/testdomain.com/record',
    [
        'headers' => [
            'Authorization' => 'Bearer API_KEY',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'record_type_name' => 'A',
            'record_name' => 'test',
            'record_data' => '1.2.3.4',
            'priority' => 1,
            'fallback_ip' => '1.2.3.4',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.nomeo.com/domains/testdomain.com/record'
payload = {
    "record_type_name": "A",
    "record_name": "test",
    "record_data": "1.2.3.4",
    "priority": 1,
    "fallback_ip": "1.2.3.4"
}
headers = {
  'Authorization': 'Bearer API_KEY',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200):


{
    "success": true,
    "message": "The record has been added to the zone!",
    "data": {
        "record_id": 123
    },
    "customData": []
}

Request   

POST domains/{domain}/record

URL Parameters

domain  string  

Domain name.

Body Parameters

record_type_name  string  

Record type name.
Avaiable options: SOA,A,AAAA,CNAME,ANAME,MX,TXT,SRV,CAA,NS,DS,LUA.

record_name  string  

Record name. Number of chars between 1-100.

record_data  string  

Record data. Number of chars between 1-100.

priority  integer  

Priority, between 1-1000.

fallback_ip  string optional  

Fallback IP if record_type_name=A.

Update domain DNS record

requires authentication

Example request:
curl --request PUT \
    "https://api.nomeo.com/domains/testdomain.com/record" \
    --header "Authorization: Bearer API_KEY" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"id\": \"1\",
    \"record_type_name\": \"A\",
    \"record_name\": \"test\",
    \"record_data\": \"1.2.3.4\",
    \"priority\": 1,
    \"fallback_ip\": \"1.2.3.4\"
}"

const url = new URL(
    "https://api.nomeo.com/domains/testdomain.com/record"
);

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

let body = {
    "id": "1",
    "record_type_name": "A",
    "record_name": "test",
    "record_data": "1.2.3.4",
    "priority": 1,
    "fallback_ip": "1.2.3.4"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->put(
    'https://api.nomeo.com/domains/testdomain.com/record',
    [
        'headers' => [
            'Authorization' => 'Bearer API_KEY',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'id' => '1',
            'record_type_name' => 'A',
            'record_name' => 'test',
            'record_data' => '1.2.3.4',
            'priority' => 1,
            'fallback_ip' => '1.2.3.4',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.nomeo.com/domains/testdomain.com/record'
payload = {
    "id": "1",
    "record_type_name": "A",
    "record_name": "test",
    "record_data": "1.2.3.4",
    "priority": 1,
    "fallback_ip": "1.2.3.4"
}
headers = {
  'Authorization': 'Bearer API_KEY',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200):


{
    "success": true,
    "message": "The record has been updated!",
    "data": [],
    "customData": []
}

Request   

PUT domains/{domain}/record

URL Parameters

domain  string  

Domain name.

Body Parameters

id  string  

Record ID.

record_type_name  string  

Record type name.
Avaiable options: SOA,A,AAAA,CNAME,ANAME,MX,TXT,SRV,CAA,NS,DS,LUA.

record_name  string  

Record name. Number of chars between 1-100.

record_data  string  

Record data. Number of chars between 1-100.

priority  integer  

Priority, between 1-1000.

fallback_ip  string optional  

Fallback IP if record_type_name=A.

Delete domain DNS record

requires authentication

Example request:
curl --request DELETE \
    "https://api.nomeo.com/domains/testdomain.com/record/1" \
    --header "Authorization: Bearer API_KEY" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.nomeo.com/domains/testdomain.com/record/1"
);

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

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

url = 'https://api.nomeo.com/domains/testdomain.com/record/1'
headers = {
  'Authorization': 'Bearer API_KEY',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200):


{
    "success": true,
    "message": "The record has been deleted!",
    "data": [],
    "customData": []
}

Request   

DELETE domains/{domain}/record/{recordId}

URL Parameters

domain  string optional  

Domain name.

recordId  integer  

Record id.

Change nameservers

requires authentication

Example request:
curl --request POST \
    "https://api.nomeo.com/domains/domain.com/change-nameservers" \
    --header "Authorization: Bearer API_KEY" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"ns1\": \"ns1.com\",
    \"ns2\": \"ns2.com\",
    \"ns3\": \"ns3.com\",
    \"ns4\": \"ns4.com\"
}"

const url = new URL(
    "https://api.nomeo.com/domains/domain.com/change-nameservers"
);

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

let body = {
    "ns1": "ns1.com",
    "ns2": "ns2.com",
    "ns3": "ns3.com",
    "ns4": "ns4.com"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://api.nomeo.com/domains/domain.com/change-nameservers',
    [
        'headers' => [
            'Authorization' => 'Bearer API_KEY',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'ns1' => 'ns1.com',
            'ns2' => 'ns2.com',
            'ns3' => 'ns3.com',
            'ns4' => 'ns4.com',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.nomeo.com/domains/domain.com/change-nameservers'
payload = {
    "ns1": "ns1.com",
    "ns2": "ns2.com",
    "ns3": "ns3.com",
    "ns4": "ns4.com"
}
headers = {
  'Authorization': 'Bearer API_KEY',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (201):


{
    "ResultCode": 1,
    "ResultMessage": "Updated domain nameservers!",
    "Success": true
}

Request   

POST domains/{domain}/change-nameservers

URL Parameters

domain  string  

Domain name. Number of chars between 5-100.

Body Parameters

ns1  string  

Name Server 1. Number of chars between 5-100.

ns2  string  

Name Server 2. Number of chars between 5-100.

ns3  string optional  

Name Server 3. Number of chars between 5-100.

ns4  string optional  

Name Server 4. Number of chars between 5-100.

Products

Products APIs

Get list of Partner's Services

requires authentication

Example request:
curl --request GET \
    --get "https://api.nomeo.com/products/services?client_id=1" \
    --header "Authorization: Bearer API_KEY" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.nomeo.com/products/services"
);

const params = {
    "client_id": "1",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

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

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

url = 'https://api.nomeo.com/products/services'
params = {
  'client_id': '1',
}
headers = {
  'Authorization': 'Bearer API_KEY',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200):


{
    "data": [
        {
            "id": "123",
            "pid": "123",
            "client_id": "123",
            "name": "Microsoft 365 - NCE",
            "next_due_date": "2022-07-01",
            "domain": "test.onmicrosoft.com",
            "status": "Active",
            "billing_cycle": "Monthly",
            "reg_date": "2022-07-01",
            "first_payment_amount": "0.00",
            "recurring_amount": "0.00",
            "days_remain": -229,
            "login": "",
            "password": "",
            "reg_number": "",
            "number_of_users": "",
            "gdata_valid_until": "2023-07-01",
            "platform": ""
        }
    ]
}

Request   

GET products/services

Query Parameters

client_id  integer optional  

Filter by Client ID.

Get list of Partner's Licenses

requires authentication

Example request:
curl --request GET \
    --get "https://api.nomeo.com/products/licenses" \
    --header "Authorization: Bearer API_KEY" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.nomeo.com/products/licenses"
);

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

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

url = 'https://api.nomeo.com/products/licenses'
headers = {
  'Authorization': 'Bearer API_KEY',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200):


{
    "licenses": [
        {
            "id": "123",
            "pid": "123",
            "client_id": "123",
            "name": "Gdata Internet Security",
            "next_due_date": "2021-09-14",
            "domain": "test",
            "status": "Active",
            "billing_cycle": "One Time",
            "reg_date": "2021-09-14",
            "first_payment_amount": "114.97",
            "recurring_amount": "181.78",
            "days_remain": -519,
            "login": "",
            "password": "",
            "reg_number": "",
            "number_of_users": "",
            "gdata_valid_until": "2022-09-14",
            "platform": ""
        }
    ],
    "expiringWithin60days": 0
}

Request   

GET products/licenses

Get Subscription Catalog

requires authentication

Important Notes: This api will return all subscription catalog, with "Terms". You can use this term information to use correct term duration and billing circle value when use "Add a new M365 subscription" API.

Example: "Terms": ["P1M:P1M","P1Y:P1Y","P1Y:P1M"] => List of available term duration & billing circle for this Catalog. When user choose "P1M" term duration, they can choose "P1M" billing circle only. When user choose "P1Y" term duration, they can choose "P1Y" or "P1M" billing circle.

Display value for user: P1M: Monthly, P1Y: Annually, P3Y: Triennially, P1X: One-Time

Example request:
curl --request GET \
    --get "https://api.nomeo.com/products/m365/catalog" \
    --header "Authorization: Bearer API_KEY" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.nomeo.com/products/m365/catalog"
);

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

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

url = 'https://api.nomeo.com/products/m365/catalog'
headers = {
  'Authorization': 'Bearer API_KEY',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200):


{
    "success": true,
    "message": "Subscription Catalog",
    "data": [
        {
            "Title": "Azure Active Directory Premium P1",
            "Description": "Azure Active Directory Premium provides single sign-on to thousands of cloud (SaaS) apps and access to web apps you run on-premises. Built for ease of use, Azure Active Directory Premium features multi-factor authentication (MFA); access control based on device health, user location, and identity; and holistic security reports, audits, and alerts.\r\nAzure Active Directory Premium provides single sign-on to thousands of cloud (SaaS) apps and access to web apps you run on-premises. Built for ease of use, Azure Active Directory Premium features multi-factor authentication (MFA); access control based on device health, user location, and identity; and holistic security reports, audits, and alerts.",
            "Terms": [
                "P1M:P1M",
                "P1Y:P1Y",
                "P1Y:P1M"
            ],
            "Id": "75",
            "ProductSKU": "SKUNUMBER"
        }
    ]
}

Request   

GET products/m365/catalog

Add Tenant

requires authentication

Example request:
curl --request POST \
    "https://api.nomeo.com/products/m365/tenant" \
    --header "Authorization: Bearer API_KEY" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"tenant_name\": \"testtenant\",
    \"client_id\": 1
}"

const url = new URL(
    "https://api.nomeo.com/products/m365/tenant"
);

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

let body = {
    "tenant_name": "testtenant",
    "client_id": 1
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://api.nomeo.com/products/m365/tenant',
    [
        'headers' => [
            'Authorization' => 'Bearer API_KEY',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'tenant_name' => 'testtenant',
            'client_id' => 1,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.nomeo.com/products/m365/tenant'
payload = {
    "tenant_name": "testtenant",
    "client_id": 1
}
headers = {
  'Authorization': 'Bearer API_KEY',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (201):


{
    "success": true,
    "message": "Added Tenant",
    "data": {
        "service_id": "18868"
    },
    "customData": []
}

Request   

POST products/m365/tenant

Body Parameters

tenant_name  string  

Tenant name without .onmicrosoft.com. Number of chars between 1-100, must be entirely alpha-numeric characters.

client_id  integer optional  

Client ID. You can get Client id in "Get list clients" API.

Check the availability of the Microsoft tenant name

requires authentication

Example request:
curl --request GET \
    --get "https://api.nomeo.com/products/m365/check-tenant" \
    --header "Authorization: Bearer API_KEY" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"tenant_name\": \"testtenant\"
}"

const url = new URL(
    "https://api.nomeo.com/products/m365/check-tenant"
);

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

let body = {
    "tenant_name": "testtenant"
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://api.nomeo.com/products/m365/check-tenant',
    [
        'headers' => [
            'Authorization' => 'Bearer API_KEY',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'tenant_name' => 'testtenant',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.nomeo.com/products/m365/check-tenant'
payload = {
    "tenant_name": "testtenant"
}
headers = {
  'Authorization': 'Bearer API_KEY',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (201):


{
    "success": true,
    "available": true,
    "message": "test.onmicrosoft.com is available to register!"
}

Request   

GET products/m365/check-tenant

Body Parameters

tenant_name  string  

Tenant name without .onmicrosoft.com. Number of chars between 1-100, must be entirely alpha-numeric characters.

Add a new M365 subscription

requires authentication

Example request:
curl --request POST \
    "https://api.nomeo.com/products/1/m365/subscription" \
    --header "Authorization: Bearer API_KEY" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"quantity\": 1,
    \"term_duration\": \"P1M\",
    \"billing_cycle\": \"P1M\",
    \"catalog_id\": 77
}"

const url = new URL(
    "https://api.nomeo.com/products/1/m365/subscription"
);

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

let body = {
    "quantity": 1,
    "term_duration": "P1M",
    "billing_cycle": "P1M",
    "catalog_id": 77
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://api.nomeo.com/products/1/m365/subscription',
    [
        'headers' => [
            'Authorization' => 'Bearer API_KEY',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'quantity' => 1,
            'term_duration' => 'P1M',
            'billing_cycle' => 'P1M',
            'catalog_id' => 77,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.nomeo.com/products/1/m365/subscription'
payload = {
    "quantity": 1,
    "term_duration": "P1M",
    "billing_cycle": "P1M",
    "catalog_id": 77
}
headers = {
  'Authorization': 'Bearer API_KEY',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200):


{
    "success": true,
    "data": {
        "TenantId": "x-x-x-x-x",
        "ErpOrderId": "123",
        "IsAddonOrder": false,
        "Subscriptions": [
            {
                "AutoRenewEnabled": true,
                "BillingCycle": "P1M",
                "CustomTermEndDate": null,
                "ErpOrderId": null,
                "FriendlyName": "Azure Active Directory Premium P1",
                "OfferId": "CFQ7TTC0LH16:0001",
                "OrderId": null,
                "PartnerId": "123",
                "ProductId": "77",
                "Quantity": 1,
                "SkuId": null,
                "Status": 1,
                "SubscriptionId": "",
                "TenantId": "x-x-x-x-x",
                "TermDuration": "P1M",
                "WhmcsServiceId": null
            }
        ]
    }
}

Request   

POST products/{serviceId}/m365/subscription

URL Parameters

serviceId  integer  

Service ID. You can get Service id in "Get list of Partner's Services" API.

Body Parameters

quantity  integer  

Quantity, Must between 1-100.

term_duration  string  

Term Duration.
Available options: P1M,P1Y,P3Y,P1X.
Please read this document to get value: "Get Subscription Catalog" A PI.

billing_cycle  string  

Billing Duration.
Available options: P1M,P1Y,P3Y,P1X.
Please read this document to get value: "Get Subscription Catalog" API.

catalog_id  integer  

Subscription Catalog Id. You can get Subscription Catalog Id in "Get Subscription Catalog" API.

Update M365 subscription quantity

requires authentication

Example request:
curl --request POST \
    "https://api.nomeo.com/products/1/m365/subscription/9cb50556-0000-40000-0000-3fdcc63ad0fd/update/quantity" \
    --header "Authorization: Bearer API_KEY" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"quantity\": 1
}"

const url = new URL(
    "https://api.nomeo.com/products/1/m365/subscription/9cb50556-0000-40000-0000-3fdcc63ad0fd/update/quantity"
);

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

let body = {
    "quantity": 1
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://api.nomeo.com/products/1/m365/subscription/9cb50556-0000-40000-0000-3fdcc63ad0fd/update/quantity',
    [
        'headers' => [
            'Authorization' => 'Bearer API_KEY',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'quantity' => 1,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.nomeo.com/products/1/m365/subscription/9cb50556-0000-40000-0000-3fdcc63ad0fd/update/quantity'
payload = {
    "quantity": 1
}
headers = {
  'Authorization': 'Bearer API_KEY',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200):


{
    "success": true,
    "message": "Subscription has been updated!",
    "data": {
        "TenantId": "fe1403d5-0000-0000-0000-7cded881c91d",
        "ErpOrderId": "1000",
        "IsAddonOrder": false,
        "Subscriptions": [
            {
                "AutoRenewEnabled": true,
                "BillingCycle": "Monthly",
                "CustomTermEndDate": null,
                "ErpOrderId": null,
                "FriendlyName": "Microsoft 365 Business Standard",
                "OfferId": "CFQ7TTC0LDPB:0001",
                "OrderId": "000000000000",
                "PartnerId": "1000000",
                "ProductId": null,
                "Quantity": 1,
                "SkuId": null,
                "Status": 0,
                "SubscriptionId": "90f37eae-0000-0000-0000-1ee0fa9ffdb9",
                "TenantId": "fe1403d5-0000-0000-0000-7cded881c91d",
                "TermDuration": "P1Y",
                "WhmcsServiceId": null
            }
        ]
    },
    "customData": []
}

Request   

POST products/{serviceId}/m365/subscription/{subscriptionId}/update/quantity

URL Parameters

serviceId  integer  

Service ID. You can get Service id in "Get list of Partner's Services" API.

subscriptionId  string  

Subscription ID.

Body Parameters

quantity  integer  

Quantity, Must between 1-10000.

Get list of User's M365 subscriptions

requires authentication

Example request:
curl --request GET \
    --get "https://api.nomeo.com/products/1/m365/subscriptions" \
    --header "Authorization: Bearer API_KEY" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.nomeo.com/products/1/m365/subscriptions"
);

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

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

url = 'https://api.nomeo.com/products/1/m365/subscriptions'
headers = {
  'Authorization': 'Bearer API_KEY',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200):


{
    "nce_licenses": [
        {
            "AutoRenewEnabled": false,
            "ProductId": 1,
            "AvailableUnits": 2,
            "BillingCycle": "Monthly",
            "CancellationAllowedUntilDate": "29/01/2023",
            "CatalogItemId": "ABC:0001:123",
            "CommitmentEndDate": "21/02/2023",
            "ConsumedUnits": 0,
            "CreationDate": "22/12/2022",
            "EffectiveStartDate": "22/12/2022",
            "FriendlyName": "Exchange Online (Plan 1)",
            "IsNewCommerceExperienceSubscription": true,
            "MinimumQuantity": 2,
            "NextTermInstructions": null,
            "OfferId": "ABC:0001",
            "OrderId": "123abc",
            "ParentSubscriptionId": null,
            "PartnerId": "123",
            "ProductSku": "CFQ7TTC0LH16:0001",
            "PromotionId": null,
            "SkuPartNumber": "UNKNOWN",
            "Status": 0,
            "SubscriptionId": "378dc3d8-1234-1234-1234-eed13edbeacd",
            "SubscriptionQuantity": 2,
            "TenantId": "5f5e68d7-1234-1234-1234-a5ea6972ddb5",
            "TermDuration": "P1M",
            "TotalUnits": 2,
            "IsAddon": false,
            "AllowCancel": false,
            "MinQuantity": 2,
            "RecentTransactions": [],
            "microsoft_standard_end_user_price": null,
            "reseller_end_user_price": null,
            "actual_sale_price": null,
            "user_price": null,
            "user_item_price": null,
            "end_dates_sort": [
                {
                    "original": "/Date(1708487255000)/",
                    "formatted": "21/02/2024"
                }
            ]
        }
    ]
}

Request   

GET products/{serviceId}/m365/subscriptions

URL Parameters

serviceId  integer  

Service ID. You can get Service id in "Get list of Partner's Services" API.