MENU navbar-image

Introduction

Welcome to official Euronic Client API!

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

As you scroll, you'll see code examples for working with the API in different programming languages in the area to the right (or as part of the content on mobile). You can switch the language used with the tabs at the top right (or from the nav menu at the top left on mobile).

Base URL

https://api.euronic.fi/

Authenticating requests

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

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

You can obtain your access token by authenticating yourself as described below.

Authentication

Authentication

Authenticate via credentials (username & password).

The credentials are identical to the ones you will use to login in to the client page. If you are unable to use your credentials or do not remember your credentials, you can always contact us via e-mail to restore your login credentials.

Upon valid authentication, you'll get a 200 OK response with access token you can use to authorize further API requests that requires authentication.

Otherwise, the request will fail with a 422 error, with an error message and a status code.

Example request:
curl --request POST \
    "https://api.euronic.fi/api/v1/auth" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"username\": \"neque\",
    \"password\": \"incidunt\"
}"
const url = new URL(
    "https://api.euronic.fi/api/v1/auth"
);

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

let body = {
    "username": "neque",
    "password": "incidunt"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://api.euronic.fi/api/v1/auth',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'username' => 'neque',
            'password' => 'incidunt',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.euronic.fi/api/v1/auth'
payload = {
    "username": "neque",
    "password": "incidunt"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200):


{
    "message": "",
    "data": {
        "token": "eyJ0ex...",
        "token_type": "bearer",
        "expires_in": 86400
    }
}
 

Example response (422, Invalid input data):


{
    "error": {
        "status": 422,
        "message": "The given data was invalid.",
        "context": {
            "username": [
                "The username is required"
            ],
            "password": [
                "The password is required"
            ]
        }
    }
}
 

Example response (422, Invalid credentials):


{
    "error": {
        "status": 422,
        "message": "Invalid credentials"
    }
}
 

Request   

POST api/v1/auth

Body Parameters

username  string  

password  string  

Response

Response Fields

message  string  

The response message, empty string when request was succesfull.

token  string  

The access token.

token_type  string  

The type of token (always bearer).

expires_in  integer  

The value in seconds of when the access token is no longer valid (always 86400, equivalent to 24 hours).

Refresh token

requires authentication

Generates a new token from previous token given in headers.

Upon succesfull request, you'll get a 200 OK response with new access token you can use to authorize further API requests that requires authentication.

If token is not present with the request headers, token is expired and can no longer be refreshed, the request will fail with a 401 error.

Example request:
curl --request GET \
    --get "https://api.euronic.fi/api/v1/auth/refresh" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.euronic.fi/api/v1/auth/refresh"
);

const headers = {
    "Authorization": "Bearer {token}",
    "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.euronic.fi/api/v1/auth/refresh',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.euronic.fi/api/v1/auth/refresh'
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200):


{
    "message": "",
    "data": {
        "token": "eyJ0ex...",
        "token_type": "bearer",
        "expires_in": 86400
    }
}
 

Example response (401, Access token not provided):


{
"error": {
  "status": 401,
  "message": "Access token error",
}
}
 

Example response (401, Expired Access token):


{
    "error": {
        "status": 401,
        "message": "Expired Access token"
    }
}
 

Request   

GET api/v1/auth/refresh

Response

Response Fields

message  string  

The response message, empty string when request was succesfull.

token  string  

The access token.

token_type  string  

The type of token (always bearer).

expires_in  integer  

The value in seconds of when the access token is no longer valid (always 86400, equivalent to 24 hours).

Contact

Retrieve a collection of contacts for the authenticated User

requires authentication

Example request:
curl --request GET \
    --get "https://api.euronic.fi/api/v1/contact/contacts" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.euronic.fi/api/v1/contact/contacts"
);

const headers = {
    "Authorization": "Bearer {token}",
    "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.euronic.fi/api/v1/contact/contacts',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.euronic.fi/api/v1/contact/contacts'
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200):


{
   "message": "",
   "data": [
     {
       "id": 1,
       "address": "Esimerkkikatu 1",
       "zip_code": "20100",
       "city": "Turku",
       "country": "FI",
       "contact_type": "general",
       "email": "matti.meikalainen@example.fi",
       "company_name": "Matti&Maija OY",
       "name": "Matti Meikäläinen",
       "phone": "+358.401234567",
       "alt_email": "matti@example.fi",
       "billing_email": "matti.laskut@example.fi",
       "billing_method": "email",
       "business_id": "123456-7",
       "e_invoice_address": "",
       "e_invoice_intermediator": "",
     },
     {
       "id": 2,
       "address": "Esimerkkikatu 2",
       "zip_code": "20100",
       "city": "Turku",
       "country": "FI",
       "contact_type": "billing",
       "email": "maija.meikalainen@example.fi",
       "company_name": "Matti&Maija OY",
       "name": "Maija Meikäläinen",
       "phone": "+358.401234568",
       "alt_email": "maija@example.fi",
       "billing_email": "",
       "billing_method": "e-invoice",
       "business_id": "123456-7",
       "e_invoice_address": "0123456789",
       "e_invoice_intermediator": "OKOYFIHH",
     }
    ],
    "meta": {
       "limit": 100,
       "offset": 0,
       "count": 2,
       "total": 2
     }
}
 

Example response (401, Authorization token not provided or invalid):


{
  "error": {
    "status": 401,
    "message": "Unauthorized request",
  }
}
 

Request   

GET api/v1/contact/contacts

Response

Response Fields

id  integer  

The identifier of Contact

address  string  

Address

zip_code  string  

Zip code

city  string  

City

country  string  

Two letter country code in ISO 639-1 format

contact_type  string  

Type of contact (billing, general)

email  string  

Email address

company_name  string  

Company name

name  string  

Contact name

phone  string  

Phone number

alt_email  string  

Secondary email address

billing_email  string  

Billing email address

billing_method  string  

Default billing method (email, post, e-invoice)

business_id  string  

Business ID

e_invoice_address  string  

E-Invoice address

e_invoice_intermediator  string  

E-Invoice intermediator

meta.limit  integer  

The limit of results returned

meta.offset  integer  

The current offset of returned results

meta.count  integer  

Total number of items in the response

meta.total  integer  

Total number of items

Retrieve details for the specified Contact

requires authentication

Example request:
curl --request GET \
    --get "https://api.euronic.fi/api/v1/contact/contacts/1" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.euronic.fi/api/v1/contact/contacts/1"
);

const headers = {
    "Authorization": "Bearer {token}",
    "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.euronic.fi/api/v1/contact/contacts/1',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.euronic.fi/api/v1/contact/contacts/1'
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200):


{
   "message": "",
   "data": {
     "id": 1,
     "address": "Esimerkkikatu 1",
     "zip_code": "20100",
     "city": "Turku",
     "country": "FI",
     "contact_type": "general",
     "email": "matti.meikalainen@example.fi",
     "company_name": "Matti&Maija OY",
     "name": "Matti Meikäläinen",
     "phone": "+358.401234567",
     "alt_email": "matti@example.fi",
     "billing_email": "matti.laskut@example.fi",
     "billing_method": "email",
     "business_id": "123456-7",
     "e_invoice_address": "",
     "e_invoice_intermediator": "",
   }
}
 

Example response (401, Authorization token not provided):


{
  "error": {
    "status": 401,
    "message": "Unauthorized request",
  }
}
 

Example response (403, Contact is not assigned to the User):


{
  "error": {
    "status": 403,
    "message": "Forbidden request",
  }
}
 

Request   

GET api/v1/contact/contacts/{id}

URL Parameters

id  integer  

The requested contact id

Response

Response Fields

id  integer  

The identifier of Contact

address  string  

Address

zip_code  string  

Zip code

city  string  

City

country  string  

Two letter country code in ISO 639-1 format

contact_type  string  

Type of contact (billing, general)

email  string  

Email address

company_name  string  

Company name

name  string  

Contact name

phone  string  

Phone number

alt_email  string  

Secondary email address

billing_email  string  

Billing email address

billing_method  string  

Default billing method (email, post, e-invoice)

business_id  string  

Business ID

e_invoice_address  string  

E-Invoice address

e_invoice_intermediator  string  

E-Invoice intermediator

Create a new contact

requires authentication

Example request:
curl --request POST \
    "https://api.euronic.fi/api/v1/contact/contacts" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"address\": \"Testikatu 1\",
    \"zip_code\": \"20100\",
    \"city\": \"Turku\",
    \"country\": \"FI\",
    \"company_name\": \"My Company\",
    \"business_id\": \"1234567-8\",
    \"first_name\": \"Matti\",
    \"last_name\": \"Meikäläinen\",
    \"phone\": \"+358.401234567\",
    \"email\": \"matti@example.fi\",
    \"alt_email\": \"matti2@example.fi\",
    \"billing_email\": \"matti_billing@example.fi\",
    \"billing_method\": \"email\",
    \"e_invoice_address\": \"0123456789\",
    \"e_invoice_intermediator\": \"OKOYFIHH\"
}"
const url = new URL(
    "https://api.euronic.fi/api/v1/contact/contacts"
);

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

let body = {
    "address": "Testikatu 1",
    "zip_code": "20100",
    "city": "Turku",
    "country": "FI",
    "company_name": "My Company",
    "business_id": "1234567-8",
    "first_name": "Matti",
    "last_name": "Meikäläinen",
    "phone": "+358.401234567",
    "email": "matti@example.fi",
    "alt_email": "matti2@example.fi",
    "billing_email": "matti_billing@example.fi",
    "billing_method": "email",
    "e_invoice_address": "0123456789",
    "e_invoice_intermediator": "OKOYFIHH"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://api.euronic.fi/api/v1/contact/contacts',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'address' => 'Testikatu 1',
            'zip_code' => '20100',
            'city' => 'Turku',
            'country' => 'FI',
            'company_name' => 'My Company',
            'business_id' => '1234567-8',
            'first_name' => 'Matti',
            'last_name' => 'Meikäläinen',
            'phone' => '+358.401234567',
            'email' => 'matti@example.fi',
            'alt_email' => 'matti2@example.fi',
            'billing_email' => 'matti_billing@example.fi',
            'billing_method' => 'email',
            'e_invoice_address' => '0123456789',
            'e_invoice_intermediator' => 'OKOYFIHH',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.euronic.fi/api/v1/contact/contacts'
payload = {
    "address": "Testikatu 1",
    "zip_code": "20100",
    "city": "Turku",
    "country": "FI",
    "company_name": "My Company",
    "business_id": "1234567-8",
    "first_name": "Matti",
    "last_name": "Meikäläinen",
    "phone": "+358.401234567",
    "email": "matti@example.fi",
    "alt_email": "matti2@example.fi",
    "billing_email": "matti_billing@example.fi",
    "billing_method": "email",
    "e_invoice_address": "0123456789",
    "e_invoice_intermediator": "OKOYFIHH"
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (201):


{
    "message": "New contact created successfully",
    "data": null
}
 

Example response (401, Authorization token not provided or invalid):


{
  "error": {
    "status": 401,
    "message": "Unauthorized request",
  }
}
 

Example response (422, Validation error):


{
    "error": {
        "status": 422,
        "message": "The given data was invalid.",
        "context": {
            "address": [
                "The address is required"
            ]
        }
    }
}
 

Request   

POST api/v1/contact/contacts

Body Parameters

address  string  

zip_code  string  

must be between 5 and 10 characters

city  string  

country  string  

two letter country code in ISO 639-1 format

company_name  string optional  

only required if first_name and last_name are not provided

business_id  string optional  

only required if company_name is provided

first_name  string optional  

only required with last_name and if company_name is not provided

last_name  string optional  

only required with first_name and if company_name is not provided

phone  string  

must be in the following format: +xxx.xxxxxxx

email  string  

alt_email  string optional  

billing_email  string optional  

billing_method  string  

must be one of the following: email, post, e-invoice

e_invoice_address  string optional  

only required when billing_method is set to e-invoice

e_invoice_intermediator  string optional  

only required when billing_method is set to e-invoice

Response

Response Fields

message  string  

Update existing contact

requires authentication

Returns updated contact

Example request:
curl --request PATCH \
    "https://api.euronic.fi/api/v1/contact/contacts/1" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"address\": \"Esimerkkikatu 1\",
    \"zip_code\": \"20100\",
    \"city\": \"Turku\",
    \"country\": \"FI\",
    \"company_name\": \"My Company\",
    \"business_id\": \"1234567-8\",
    \"first_name\": \"Matti\",
    \"last_name\": \"Meikäläinen\",
    \"phone\": \"+358.401234567\",
    \"email\": \"matti.meikalainen@example.fi\",
    \"alt_email\": \"matti2@example.fi\",
    \"billing_email\": \"matti_billing@example.fi\",
    \"billing_method\": \"email\",
    \"e_invoice_address\": \"0123456789\",
    \"e_invoice_intermediator\": \"OKOYFIHH\"
}"
const url = new URL(
    "https://api.euronic.fi/api/v1/contact/contacts/1"
);

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

let body = {
    "address": "Esimerkkikatu 1",
    "zip_code": "20100",
    "city": "Turku",
    "country": "FI",
    "company_name": "My Company",
    "business_id": "1234567-8",
    "first_name": "Matti",
    "last_name": "Meikäläinen",
    "phone": "+358.401234567",
    "email": "matti.meikalainen@example.fi",
    "alt_email": "matti2@example.fi",
    "billing_email": "matti_billing@example.fi",
    "billing_method": "email",
    "e_invoice_address": "0123456789",
    "e_invoice_intermediator": "OKOYFIHH"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'https://api.euronic.fi/api/v1/contact/contacts/1',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'address' => 'Esimerkkikatu 1',
            'zip_code' => '20100',
            'city' => 'Turku',
            'country' => 'FI',
            'company_name' => 'My Company',
            'business_id' => '1234567-8',
            'first_name' => 'Matti',
            'last_name' => 'Meikäläinen',
            'phone' => '+358.401234567',
            'email' => 'matti.meikalainen@example.fi',
            'alt_email' => 'matti2@example.fi',
            'billing_email' => 'matti_billing@example.fi',
            'billing_method' => 'email',
            'e_invoice_address' => '0123456789',
            'e_invoice_intermediator' => 'OKOYFIHH',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.euronic.fi/api/v1/contact/contacts/1'
payload = {
    "address": "Esimerkkikatu 1",
    "zip_code": "20100",
    "city": "Turku",
    "country": "FI",
    "company_name": "My Company",
    "business_id": "1234567-8",
    "first_name": "Matti",
    "last_name": "Meikäläinen",
    "phone": "+358.401234567",
    "email": "matti.meikalainen@example.fi",
    "alt_email": "matti2@example.fi",
    "billing_email": "matti_billing@example.fi",
    "billing_method": "email",
    "e_invoice_address": "0123456789",
    "e_invoice_intermediator": "OKOYFIHH"
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200):


{
   "message": "",
   "data": {
     "id": 1,
     "address": "Esimerkkikatu 1",
     "zip_code": "20100",
     "city": "Turku",
     "country": "FI",
     "contact_type": "general",
     "email": "matti.meikalainen@example.fi",
     "company_name": "My Company",
     "name": "Matti Meikäläinen",
     "phone": "+358.401234567",
     "alt_email": "matti2@example.fi",
     "billing_email": "matti_billing@example.fi",
     "billing_method": "email",
     "business_id": "1234567-8",
     "e_invoice_address": "0123456789",
     "e_invoice_intermediator": "OKOYFIHH",
   }
}
 

Example response (401, Authorization token not provided or invalid):


{
  "error": {
    "status": 401,
    "message": "Unauthorized request",
  }
}
 

Example response (403, Contact is not assigned to the User):


{
  "error": {
    "status": 403,
    "message": "Forbidden request",
  }
}
 

Example response (422, Validation error):


{
    "error": {
        "status": 422,
        "message": "The given data was invalid.",
        "context": {
            "address": [
                "The address is required"
            ]
        }
    }
}
 

Request   

PATCH api/v1/contact/contacts/{id}

URL Parameters

id  integer  

The contact id to be updated

Body Parameters

address  string  

zip_code  string  

must be between 5 and 10 characters

city  string  

country  string  

two letter country code in ISO 639-1 format

company_name  string optional  

only required if first_name and last_name are not provided

business_id  string optional  

only required if company_name is provided

first_name  string optional  

only required with last_name and if company_name is not provided

last_name  string optional  

only required with first_name and if company_name is not provided

phone  string  

must be in the following format: +xxx.xxxxxxx

email  string  

alt_email  string optional  

billing_email  string optional  

billing_method  string  

must be one of the following: email, post, e-invoice

e_invoice_address  string optional  

only required when billing_method is set to e-invoice

e_invoice_intermediator  string optional  

only required when billing_method is set to e-invoice

Response

Response Fields

id  integer  

The identifier of Contact

address  string  

Address

zip_code  string  

Zip code

city  string  

City

country  string  

Two letter country code in ISO 639-1 format

contact_type  string  

Type of contact (billing, general)

email  string  

Email address

company_name  string  

Company name

name  string  

Contact name

phone  string  

Phone number

alt_email  string  

Secondary email address

billing_email  string  

Billing email address

billing_method  string  

Default billing method (email, post, e-invoice)

business_id  string  

Business ID

e_invoice_address  string  

E-Invoice address

e_invoice_intermediator  string  

E-Invoice intermediator

Delete an existing Contact

requires authentication

Example request:
curl --request DELETE \
    "https://api.euronic.fi/api/v1/contact/contacts/1" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.euronic.fi/api/v1/contact/contacts/1"
);

const headers = {
    "Authorization": "Bearer {token}",
    "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.euronic.fi/api/v1/contact/contacts/1',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.euronic.fi/api/v1/contact/contacts/1'
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200):


{
    "message": "Contact deleted succesfully",
    "data": null
}
 

Example response (400, Contact is assigned to at least one Domain):


{
  "error": {
    "status": 400,
    "message": "Contact cannot be deleted as it is assigned to at least one domain",
  }
}
 

Example response (400, Primary contact deletion):


{
  "error": {
    "status": 400,
    "message": "Primary contact cannot be deleted",
  }
}
 

Example response (403, Contact is not assigned to the User):


{
  "error": {
    "status": 403,
    "message": "Forbidden request",
  }
}
 

Request   

DELETE api/v1/contact/contacts/{id}

URL Parameters

id  integer  

The contact id to be deleted

Response

Response Fields

message  string  

Domain

Domains - Retrieve a collection of domains for the authenticated User

requires authentication

Returns Domain data along with contact information assigned to Domain

Example request:
curl --request GET \
    --get "https://api.euronic.fi/api/v1/domain/domains" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.euronic.fi/api/v1/domain/domains"
);

const headers = {
    "Authorization": "Bearer {token}",
    "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.euronic.fi/api/v1/domain/domains',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.euronic.fi/api/v1/domain/domains'
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200):


{
   "message": "",
   "data": [
     {
       "id": 1,
       "sld": "test",
       "tld": "com",
       "fqdn": "test.com",
       "fqdn_unicode": "test.com",
       "reg_date": "2022-08-01",
       "exp_date": "2023-08-01",
       "status": "active",
       "renew": true,
       "updated_at": null,
       "billing_contact": {
         "id": 1,
         "address": "Esimerkkikatu 1",
         "zip_code": "20100",
         "city": "Turku",
         "country": "FI",
         "contact_type": "general",
         "email": "matti.meikalainen@example.fi",
         "company_name": "Matti&Maija OY",
         "name": "Matti Meikäläinen",
         "phone": "+358.401234567",
         "alt_email": "matti@example.fi",
         "billing_email": "matti.laskut@example.fi",
         "billing_method": "email",
         "business_id": "123456-7",
         "e_invoice_address": "",
         "e_invoice_intermediator": "",
       }
     },
     {
       "id": 2,
       "sld": "test",
       "tld": "fi",
       "fqdn": "test.fi",
       "fqdn_unicode": "test.fi",
       "reg_date": "2021-08-01",
       "exp_date": "2022-08-01",
       "status": "inactive",
       "renew": false,
       "updated_at": null,
       "billing_contact": {
         "id": 1,
         "address": "Esimerkkikatu 1",
         "zip_code": "20100",
         "city": "Turku",
         "country": "FI",
         "contact_type": "general",
         "email": "matti.meikalainen@example.fi",
         "company_name": "Matti&Maija OY",
         "name": "Matti Meikäläinen",
         "phone": "+358.401234567",
         "alt_email": "matti@example.fi",
         "billing_email": "matti.laskut@example.fi",
         "billing_method": "email",
         "business_id": "123456-7",
         "e_invoice_address": "",
         "e_invoice_intermediator": "",
       }
     }
    ],
    "meta": {
       "limit": 100,
       "offset": 0,
       "count": 2,
       "total": 2
     }
}
 

Example response (401, Authorization token not provided or invalid):


{
  "error": {
    "status": 401,
    "message": "Unauthorized request",
  }
}
 

Request   

GET api/v1/domain/domains

Query Parameters

limit  integer optional  

the limit of results returned, only required with offset

offset  integer optional  

the offset of returned results, only required with limit

Response

Response Fields

id  integer  

Identier of the domain

sld  string  

Second level domain name

tld  string  

Top level domain name

fqdn  string  

Fully qualified domain name

fqdn_unicode  string  

Fully qualified domain name in unicode format

reg_date  string  

Registration date

exp_date  string  

Expiration date

status  string  

Domain status

renew  string  

Renew status

updated_at  string  

Date and time of when domain was last modified

billing_contact.id  integer  

The identifier of Contact

billing_contact.address  string  

Address

billing_contact.zip_code  string  

Zip code

billing_contact.city  string  

City

billing_contact.country  string  

Two letter country code in ISO 639-1 format

billing_contact.contact_type  string  

Type of contact (billing, general)

billing_contact.email  string  

Email address

billing_contact.company_name  string  

Company name

billing_contact.name  string  

Contact name

billing_contact.phone  string  

Phone number

billing_contact.alt_email  string  

Secondary email address

billing_contact.billing_email  string  

Billing email address

billing_contact.billing_method  string  

Default billing method (email, post, e-invoice)

billing_contact.business_id  string  

Business ID

billing_contact.e_invoice_address  string  

E-Invoice address

billing_contact.e_invoice_intermediator  string  

E-Invoice intermediator

meta.limit  integer  

The limit of results returned

meta.offset  integer  

The current offset of returned results

meta.count  integer  

Total number of items in the response

meta.total  integer  

Total number of items

Domains - Retrieve details for the specified Domain

requires authentication

Returns Domain data along with contact information assigned to Domain

Example request:
curl --request GET \
    --get "https://api.euronic.fi/api/v1/domain/domains/test.com" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.euronic.fi/api/v1/domain/domains/test.com"
);

const headers = {
    "Authorization": "Bearer {token}",
    "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.euronic.fi/api/v1/domain/domains/test.com',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.euronic.fi/api/v1/domain/domains/test.com'
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200):


{
   "message": "",
   "data": {
     "id": 1,
     "sld": "test",
     "tld": "com",
     "fqdn": "test.com",
     "fqdn_unicode": "test.com",
     "reg_date": "2022-08-01",
     "exp_date": "2023-08-01",
     "status": "active",
     "renew": true,
     "updated_at": null,
     "billing_contact": {
       "id": 1,
       "address": "Esimerkkikatu 1",
       "zip_code": "20100",
       "city": "Turku",
       "country": "FI",
       "contact_type": "general",
       "email": "matti.meikalainen@example.fi",
       "company_name": "Matti&Maija OY",
       "name": "Matti Meikäläinen",
       "phone": "+358.401234567",
       "alt_email": "matti@example.fi",
       "billing_email": "matti.laskut@example.fi",
       "billing_method": "email",
       "business_id": "123456-7",
       "e_invoice_address": "",
       "e_invoice_intermediator": "",
     }
}
 

Example response (401, Authorization token not provided or invalid):


{
  "error": {
    "status": 401,
    "message": "Unauthorized request",
  }
}
 

Example response (403, Domain is not assigned to the User):


{
  "error": {
    "status": 403,
    "message": "Forbidden request",
  }
}
 

Request   

GET api/v1/domain/domains/{domain}

URL Parameters

domain  string  

fully qualified domain name.

Response

Response Fields

id  integer  

Identier of the domain

sld  string  

Second level domain name

tld  string  

Top level domain name

fqdn  string  

Fully qualified domain name

fqdn_unicode  string  

Fully qualified domain name in unicode format

reg_date  string  

Registration date

exp_date  string  

Expiration date

status  string  

Domain status

renew  string  

Renew status

updated_at  string  

Date and time of when domain was last modified

billing_contact.id  integer  

The identifier of Contact

billing_contact.address  string  

Address

billing_contact.zip_code  string  

Zip code

billing_contact.city  string  

City

billing_contact.country  string  

Two letter country code in ISO 639-1 format

billing_contact.contact_type  string  

Type of contact (billing, general)

billing_contact.email  string  

Email address

billing_contact.company_name  string  

Company name

billing_contact.name  string  

Contact name

billing_contact.phone  string  

Phone number

billing_contact.alt_email  string  

Secondary email address

billing_contact.billing_email  string  

Billing email address

billing_contact.billing_method  string  

Default billing method (email, post, e-invoice)

billing_contact.business_id  string  

Business ID

billing_contact.e_invoice_address  string  

E-Invoice address

billing_contact.e_invoice_intermediator  string  

E-Invoice intermediator

Domains - Modify the information for the Domain

requires authentication

Returns Domain data along with contact information assigned to Domain

Example request:
curl --request PATCH \
    "https://api.euronic.fi/api/v1/domain/domains/test.com" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"renew\": true,
    \"contact_id\": 1
}"
const url = new URL(
    "https://api.euronic.fi/api/v1/domain/domains/test.com"
);

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

let body = {
    "renew": true,
    "contact_id": 1
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'https://api.euronic.fi/api/v1/domain/domains/test.com',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'renew' => true,
            'contact_id' => 1,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.euronic.fi/api/v1/domain/domains/test.com'
payload = {
    "renew": true,
    "contact_id": 1
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200):


{
   "message": "",
   "data": {
     "id": 1,
     "sld": "test",
     "tld": "com",
     "fqdn": "test.com",
     "fqdn_unicode": "test.com",
     "reg_date": "2022-08-01",
     "exp_date": "2023-08-01",
     "status": "active",
     "renew": true,
     "updated_at": null,
     "billing_contact": {
       "id": 1,
       "address": "Esimerkkikatu 1",
       "zip_code": "20100",
       "city": "Turku",
       "country": "FI",
       "contact_type": "general",
       "email": "matti.meikalainen@example.fi",
       "company_name": "Matti&Maija OY",
       "name": "Matti Meikäläinen",
       "phone": "+358.401234567",
       "alt_email": "matti@example.fi",
       "billing_email": "matti.laskut@example.fi",
       "billing_method": "email",
       "business_id": "123456-7",
       "e_invoice_address": "",
       "e_invoice_intermediator": "",
     }
}
 

Example response (400, Domain expired):


{
  "error": {
    "status": 400,
    "message": "Unable to update resource: Domain already expired",
  }
}
 

Example response (401, Authorization token not provided):


{
  "error": {
    "status": 401,
    "message": "Unauthorized request",
  }
}
 

Example response (403, Domain is not assigned to the User):


{
  "error": {
    "status": 403,
    "message": "Forbidden request",
  }
}
 

Example response (422, Contact is not assigned to the User):


{
    "error": {
        "status": 422,
        "message": "The given data was invalid.",
        "context": {
            "contact_id": [
                "The given contact id is not associated with the authenticated user"
            ]
        }
    }
}
 

Request   

PATCH api/v1/domain/domains/{domain}

URL Parameters

domain  string  

fully qualified domain name

Body Parameters

renew  boolean  

boolean value to determine whether domain will be renewed or not

contact_id  integer  

contact identifier assigned to authenticated user

Response

Response Fields

id  integer  

Identier of the domain

sld  string  

Second level domain name

tld  string  

Top level domain name

fqdn  string  

Fully qualified domain name

fqdn_unicode  string  

Fully qualified domain name in unicode format

reg_date  string  

Registration date

exp_date  string  

Expiration date

status  string  

Domain status

renew  string  

Renew status

updated_at  string  

Date and time of when domain was last modified

billing_contact.id  integer  

The identifier of Contact

billing_contact.address  string  

Address

billing_contact.zip_code  string  

Zip code

billing_contact.city  string  

City

billing_contact.country  string  

Two letter country code in ISO 639-1 format

billing_contact.contact_type  string  

Type of contact (billing, general)

billing_contact.email  string  

Email address

billing_contact.company_name  string  

Company name

billing_contact.name  string  

Contact name

billing_contact.phone  string  

Phone number

billing_contact.alt_email  string  

Secondary email address

billing_contact.billing_email  string  

Billing email address

billing_contact.billing_method  string  

Default billing method (email, post, e-invoice)

billing_contact.business_id  string  

Business ID

billing_contact.e_invoice_address  string  

E-Invoice address

billing_contact.e_invoice_intermediator  string  

E-Invoice intermediator

Name Servers - Retrieve name servers for the specified Domain

requires authentication

Returns a collection of name servers for the specified Domain

Example request:
curl --request GET \
    --get "https://api.euronic.fi/api/v1/domain/domains/test.com/nameservers" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.euronic.fi/api/v1/domain/domains/test.com/nameservers"
);

const headers = {
    "Authorization": "Bearer {token}",
    "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.euronic.fi/api/v1/domain/domains/test.com/nameservers',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.euronic.fi/api/v1/domain/domains/test.com/nameservers'
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200):


{
  "message": "",
  "data": [
    {
       "nameserver": "ns1.euronic.fi",
    },
    {
       "nameserver": "ns2.euronic.fi",
    }
    {
       "nameserver": "ns3.euronic.fi",
    },
 ]
}
 

Example response (401, Authorization token not provided):


{
  "error": {
    "status": 401,
    "message": "Unauthorized request",
  }
}
 

Example response (403, Domain is not assigned to the User):


{
  "error": {
    "status": 403,
    "message": "Forbidden request",
  }
}
 

Example response (404, Resource not found):


{
  "error": {
    "status": 404,
    "message": "Resource not found",
  }
}
 

Request   

GET api/v1/domain/domains/{domain}/nameservers

URL Parameters

domain  string  

fully qualified domain name

Response

Response Fields

nameserver  string  

Nameserver address

Name Servers - Replace all name servers for the specified Domain

requires authentication

Example request:
curl --request PUT \
    "https://api.euronic.fi/api/v1/domain/domains/test.com/nameservers" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"nameservers\": [
        \"ns1.euronic.fi\",
        \"ns2.euronic.fi\"
    ]
}"
const url = new URL(
    "https://api.euronic.fi/api/v1/domain/domains/test.com/nameservers"
);

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

let body = {
    "nameservers": [
        "ns1.euronic.fi",
        "ns2.euronic.fi"
    ]
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->put(
    'https://api.euronic.fi/api/v1/domain/domains/test.com/nameservers',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'nameservers' => [
                'ns1.euronic.fi',
                'ns2.euronic.fi',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.euronic.fi/api/v1/domain/domains/test.com/nameservers'
payload = {
    "nameservers": [
        "ns1.euronic.fi",
        "ns2.euronic.fi"
    ]
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200):


{
    "message": "Name servers updated succesfully",
    "data": null
}
 

Example response (401, Authorization token not provided):


{
  "error": {
    "status": 401,
    "message": "Unauthorized request",
  }
}
 

Example response (403, Domain is not assigned to the User):


{
  "error": {
    "status": 403,
    "message": "Forbidden request",
  }
}
 

Example response (404, Resource not found):


{
  "error": {
    "status": 404,
    "message": "Resource not found",
  }
}
 

Request   

PUT api/v1/domain/domains/{domain}/nameservers

URL Parameters

domain  string  

fully qualified domain name

Body Parameters

nameservers  string[]  

Name servers, separated by comma

Response

Response Fields

message  string  

Name Servers - Add the specified name servers to the specified Domain

requires authentication

Example request:
curl --request PATCH \
    "https://api.euronic.fi/api/v1/domain/domains/test.com/nameservers" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"nameservers\": [
        \"ns1.euronic.fi\",
        \"ns2.euronic.fi\"
    ]
}"
const url = new URL(
    "https://api.euronic.fi/api/v1/domain/domains/test.com/nameservers"
);

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

let body = {
    "nameservers": [
        "ns1.euronic.fi",
        "ns2.euronic.fi"
    ]
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'https://api.euronic.fi/api/v1/domain/domains/test.com/nameservers',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'nameservers' => [
                'ns1.euronic.fi',
                'ns2.euronic.fi',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.euronic.fi/api/v1/domain/domains/test.com/nameservers'
payload = {
    "nameservers": [
        "ns1.euronic.fi",
        "ns2.euronic.fi"
    ]
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200):


{
    "message": "Name servers updated succesfully",
    "data": null
}
 

Example response (401, Authorization token not provided):


{
  "error": {
    "status": 401,
    "message": "Unauthorized request",
  }
}
 

Example response (403, Domain is not assigned to the User):


{
  "error": {
    "status": 403,
    "message": "Forbidden request",
  }
}
 

Example response (404, Resource not found):


{
  "error": {
    "status": 404,
    "message": "Resource not found",
  }
}
 

Request   

PATCH api/v1/domain/domains/{domain}/nameservers

URL Parameters

domain  string  

fully qualified domain name

Body Parameters

nameservers  string[]  

Name servers, separated by comma

Response

Response Fields

message  string  

Name Servers - Park Domain

requires authentication

Replace current name servers with Euronic's park servers (park1.euronic.fi, park2.euronic.fi, park3.euronic.fi) for the specified Domain

Example request:
curl --request PUT \
    "https://api.euronic.fi/api/v1/domain/domains/test.com/nameservers/park" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.euronic.fi/api/v1/domain/domains/test.com/nameservers/park"
);

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

fetch(url, {
    method: "PUT",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->put(
    'https://api.euronic.fi/api/v1/domain/domains/test.com/nameservers/park',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.euronic.fi/api/v1/domain/domains/test.com/nameservers/park'
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200):


{
    "message": "Name servers updated succesfully",
    "data": null
}
 

Example response (401, Authorization token not provided):


{
  "error": {
    "status": 401,
    "message": "Unauthorized request",
  }
}
 

Example response (403, Domain is not assigned to the User):


{
  "error": {
    "status": 403,
    "message": "Forbidden request",
  }
}
 

Example response (404, Resource not found):


{
  "error": {
    "status": 404,
    "message": "Resource not found",
  }
}
 

Request   

PUT api/v1/domain/domains/{domain}/nameservers/park

URL Parameters

domain  string  

fully qualified domain name

Response

Response Fields

message  string  

DNS - Retrieve DNS records for the specified Domain

requires authentication

Returns a collection of DNS records for the specified Domain

Example request:
curl --request GET \
    --get "https://api.euronic.fi/api/v1/domain/domains/test.com/records" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.euronic.fi/api/v1/domain/domains/test.com/records"
);

const headers = {
    "Authorization": "Bearer {token}",
    "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.euronic.fi/api/v1/domain/domains/test.com/records',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.euronic.fi/api/v1/domain/domains/test.com/records'
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200):


{
    "message": "",
    "data": [
        {
            "host": "@",
            "content": "127.0.0.1",
            "type": "A"
        },
        {
            "host": "www.test.com",
            "content": "test.com",
            "type": "CNAME"
        }
    ]
}
 

Example response (400, Domain does not use Euronic's name servers):


{
  "error": {
    "status": 400,
    "message": "This domain does not use Euronic's name servers.",
  }
}
 

Example response (400, Domain does not exist):


{
  "error": {
    "status": 400,
    "message": "DNS request failed: The domain name referenced in the query does not exist.",
  }
}
 

Example response (401, Authorization token not provided):


{
  "error": {
    "status": 401,
    "message": "Unauthorized request",
  }
}
 

Example response (403, Domain is not assigned to the User):


{
  "error": {
    "status": 403,
    "message": "Forbidden request",
  }
}
 

Request   

GET api/v1/domain/domains/{domain}/records

URL Parameters

domain  string  

fully qualified domain name

Response

Response Fields

host  string  

Specifies the name of the record, i.e. for example the address to which the DNS query applies string

content  string  

Target address of the record

type  string  

Type of the record (A, AAAA, CNAME, FORWARD, MX, MXE, NS, SRV, TXT, URL, URLFRAME)

pref  string  

Preference (MX Only)

redirect_type  string  

Redirection type HTTP code (URL Only)

service  string  

The symbolic name of the desired service (SRV Only)

priority  string  

The priority of the target host, lower value means more preferred (SRV Only)

proto  string  

The transport protocol of the desired service; this is usually either TCP or UDP (SRV Only)

weight  string  

Relative weight for records with the same priority, higher value means higher chance of getting picked(SRV Only)

port  string  

The TCP or UDP port on which the service is to be found (SRV Only)

Services - Retrieve a collection of services for the specified Domain

requires authentication

Example request:
curl --request GET \
    --get "https://api.euronic.fi/api/v1/domain/domains/test.com/services" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.euronic.fi/api/v1/domain/domains/test.com/services"
);

const headers = {
    "Authorization": "Bearer {token}",
    "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.euronic.fi/api/v1/domain/domains/test.com/services',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.euronic.fi/api/v1/domain/domains/test.com/services'
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200):


{
   "message": "",
   "data": [
     {
       "id": 1,
       "name": "Domainparkki",
       "qty": 1,
       "start_date": "2021-08-01",
       "exp_date": "2022-08-01",
       "status": "active",
       "renew": true,
       "updated_at": null,
       "price": {
         "total": 5.67,
         "billing_period_in_months": 12,
       }
     },
     {
       "id": 2,
       "name": "Webhotelli WebStart sis. nimipalvelu",
       "qty": 1,
       "start_date": "2021-05-11",
       "exp_date": "2024-05-11",
       "status": "active",
       "renew": false,
       "updated_at": null,
       "price": {
         "total": 117.72,
         "billing_period_in_months": 36,
       }
     },
    ],
    "meta": {
       "limit": 100,
       "offset": 0,
       "count": 2,
       "total": 2
     }
}
 

Example response (401, Authorization token not provided or invalid):


{
  "error": {
    "status": 401,
    "message": "Unauthorized request",
  }
}
 

Example response (403, Domain is not assigned to the User):


{
  "error": {
    "status": 403,
    "message": "Forbidden request",
  }
}
 

Request   

GET api/v1/domain/domains/{domain}/services

URL Parameters

domain  string  

fully qualified domain name

Response

Response Fields

id  integer  

Identier of the service

name  string  

Name of the service

qty  integer  

Quantity of service

start_date  string  

Date when service was activated

exp_date  string  

Date when service expires

status  string  

Current status of the service (active, inactive)

renew  boolean  

Whether the service will be renewed or not (true, false)

updated_at  string  

Date when service was last modified

price.total  number  

The cost of service as per billing period

price.billing_period_in_months  integer  

Billing period in months

meta.limit  integer  

The limit of results returned

meta.offset  integer  

The current offset of returned results

meta.count  integer  

Total number of items in the response

meta.total  integer  

Total number of items

Services - Update renew status of service for the specified Domain

requires authentication

Returns Service data

Example request:
curl --request PATCH \
    "https://api.euronic.fi/api/v1/domain/domains/test.com/services/1" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"renew\": true
}"
const url = new URL(
    "https://api.euronic.fi/api/v1/domain/domains/test.com/services/1"
);

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

let body = {
    "renew": true
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'https://api.euronic.fi/api/v1/domain/domains/test.com/services/1',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'renew' => true,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.euronic.fi/api/v1/domain/domains/test.com/services/1'
payload = {
    "renew": true
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200):


{
   "message": "",
   "data": {
     "id": 1,
     "name": "Domainparkki",
     "qty": 1,
     "start_date": "2021-08-01",
     "exp_date": "2022-08-01",
     "status": "active",
     "renew": true,
     "updated_at": null,
     "price": {
       "total": 5.67,
       "billing_period_in_months": 12,
     }
   }
}
 

Example response (400, Service expired):


{
  "error": {
    "status": 400,
    "message": "Unable to update resource: Service already expired",
  }
}
 

Example response (401, Authorization token not provided):


{
  "error": {
    "status": 401,
    "message": "Unauthorized request",
  }
}
 

Example response (403, Domain or Service is not assigned to the User):


{
  "error": {
    "status": 403,
    "message": "Forbidden request",
  }
}
 

Request   

PATCH api/v1/domain/domains/{domain}/services/{id}

URL Parameters

domain  string  

fully qualified domain name

id  integer  

The identifier of service to be updated

Body Parameters

renew  boolean  

boolean value to determine whether service will be renewed or not

Response

Response Fields

id  integer  

Identier of the service

name  string  

Name of the service

qty  integer  

Quantity of service

start_date  string  

Date when service was activated

exp_date  string  

Date when service expires

status  string  

Current status of the service (active, inactive)

renew  boolean  

Whether the service will be renewed or not (true, false)

updated_at  string  

Date when service was last modified

price.total  number  

The cost of service as per billing period

price.billing_period_in_months  integer  

Billing period in months

Domain Search

Domain Availability

Check domain availability details

Example request:
curl --request GET \
    --get "https://api.euronic.fi/api/v1/domain/test.com/check" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.euronic.fi/api/v1/domain/test.com/check"
);

const headers = {
    "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.euronic.fi/api/v1/domain/test.com/check',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.euronic.fi/api/v1/domain/test.com/check'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200, Single domain check):


{
    "message": "",
    "data": {
        "sld": "test",
        "tld": "com",
        "info": "unavailable",
        "status": 0
    }
}
 

Example response (200, Multi domain check):


{
    "message": "",
    "data": [
        {
            "sld": "test",
            "tld": "com",
            "info": "unavailable",
            "status": 0
        },
        {
            "sld": "test",
            "tld": "net",
            "info": "unavailable",
            "status": 0
        },
        {
            "sld": "test",
            "tld": "org",
            "info": "unavailable",
            "status": 0
        }
    ]
}
 

Example response (400, Invalid domain):


{
    "error": {
        "status": 400,
        "message": "Invalid domain"
    }
}
 

Request   

GET api/v1/domain/{domain}/check

URL Parameters

domain  string  

fully qualified domain name (eg. test.com). If tlds parameter is present, provide only SLD (eg. test in test.com).

Query Parameters

tlds  string optional  

comma separated list of top level domain names (eg. com, net, org).

Response

Response Fields

message  string  

The response message, empty string when request was succesfull.

sld  string  

The second level domain name

tld  string  

The top level domain name

info  string  

The availability status of domain (eg. available, unavailable, invalid)

status  integer  

The availability status of domain (eg. 0, 1)

Service

Retrieve a collection of services for the authenticated User

requires authentication

Example request:
curl --request GET \
    --get "https://api.euronic.fi/api/v1/service/services" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.euronic.fi/api/v1/service/services"
);

const headers = {
    "Authorization": "Bearer {token}",
    "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.euronic.fi/api/v1/service/services',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.euronic.fi/api/v1/service/services'
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200):


{
   "message": "",
   "data": [
     {
       "id": 1,
       "name": "Domainparkki",
       "qty": 1,
       "start_date": "2021-08-01",
       "exp_date": "2022-08-01",
       "status": "active",
       "renew": true,
       "updated_at": null,
       "price": {
         "total": 5.67,
         "billing_period_in_months": 12,
       }
     },
     {
       "id": 2,
       "name": "Webhotelli WebStart sis. nimipalvelu",
       "qty": 1,
       "start_date": "2021-05-11",
       "exp_date": "2024-05-11",
       "status": "active",
       "renew": false,
       "updated_at": null,
       "price": {
         "total": 117.72,
         "billing_period_in_months": 36,
       }
     },
    ],
    "meta": {
       "limit": 100,
       "offset": 0,
       "count": 2,
       "total": 2
     }
}
 

Example response (401, Authorization token not provided or invalid):


{
  "error": {
    "status": 401,
    "message": "Unauthorized request",
  }
}
 

Request   

GET api/v1/service/services

Query Parameters

limit  integer optional  

the limit of results returned, only required with offset

offset  integer optional  

the offset of returned results, only required with limit

Response

Response Fields

id  integer  

Identifier of the service

name  string  

Name of the service

qty  integer  

Quantity of the service

start_date  string  

Date when service was activated

exp_date  string  

Date when service expires

status  string  

Current status of the service (active, inactive)

renew  boolean  

Whether the service will be renewed or not (true, false)

updated_at  string  

Date when service was last modified

price.total  number  

The cost of service as per billing period

price.billing_period_in_months  integer  

Billing period in months

meta.limit  integer  

The limit of results returned

meta.offset  integer  

The current offset of returned results

meta.count  integer  

Total number of items in the response

meta.total  integer  

Total number of items

Retrieve details for the specified Service

requires authentication

Example request:
curl --request GET \
    --get "https://api.euronic.fi/api/v1/service/services/1" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.euronic.fi/api/v1/service/services/1"
);

const headers = {
    "Authorization": "Bearer {token}",
    "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.euronic.fi/api/v1/service/services/1',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.euronic.fi/api/v1/service/services/1'
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200):


{
   "message": "",
   "data": {
     "id": 1,
     "name": "Domainparkki",
     "qty": 1,
     "start_date": "2021-08-01",
     "exp_date": "2022-08-01",
     "status": "active",
     "renew": true,
     "updated_at": null,
     "price": {
       "price": 5.67,
       "billing_period_in_months": 12,
     }
   }
}
 

Example response (401, Authorization token not provided):


{
  "error": {
    "status": 401,
    "message": "Unauthorized request",
  }
}
 

Example response (403, Service is not assigned to the User):


{
  "error": {
    "status": 403,
    "message": "Forbidden request",
  }
}
 

Request   

GET api/v1/service/services/{id}

URL Parameters

id  integer  

The requested service id

Response

Response Fields

id  integer  

Identifier of the service

name  string  

Name of the service

qty  integer  

Quantity of the service

start_date  string  

Date when service was activated

exp_date  string  

Date when service expires

status  string  

Current status of the service (active, inactive)

renew  boolean  

Whether the service will be renewed or not (true, false)

updated_at  string  

Date when service was last modified

price.total  number  

The cost of service as per billing period

price.billing_period_in_months  integer  

Billing period in months

Update renew status of Service

requires authentication

Returns Service data

Example request:
curl --request PATCH \
    "https://api.euronic.fi/api/v1/service/services/1" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"renew\": true
}"
const url = new URL(
    "https://api.euronic.fi/api/v1/service/services/1"
);

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

let body = {
    "renew": true
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'https://api.euronic.fi/api/v1/service/services/1',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'renew' => true,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.euronic.fi/api/v1/service/services/1'
payload = {
    "renew": true
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200):


{
   "message": "",
   "data": {
     "id": 1,
     "name": "Domainparkki",
     "qty": 1,
     "start_date": "2021-08-01",
     "exp_date": "2022-08-01",
     "status": "active",
     "renew": true,
     "updated_at": null,
     "price": {
       "price": 5.67,
       "billing_period_in_months": 12,
     }
   }
}
 

Example response (400, Service expired):


{
  "error": {
    "status": 400,
    "message": "Unable to update resource: Service already expired",
  }
}
 

Example response (401, Authorization token not provided):


{
  "error": {
    "status": 401,
    "message": "Unauthorized request",
  }
}
 

Example response (403, Service is not assigned to the User):


{
  "error": {
    "status": 403,
    "message": "Forbidden request",
  }
}
 

Request   

PATCH api/v1/service/services/{id}

URL Parameters

id  integer  

The service id to be updated

Body Parameters

renew  boolean  

boolean value to determine whether service will be renewed or not.

Response

Response Fields

id  integer  

Identifier of the service

name  string  

Name of the service

qty  integer  

Quantity of the service

start_date  string  

Date when service was activated

exp_date  string  

Date when service expires

status  string  

Current status of the service (active, inactive)

renew  boolean  

Whether the service will be renewed or not (true, false)

updated_at  string  

Date when service was last modified

price.total  number  

The cost of service as per billing period

price.billing_period_in_months  integer  

Billing period in months

Invoice

Invoices - Retrieve a collection of invoices for the authenticated User

requires authentication

Returns invoice data along with recipient information and invoice items

Example request:
curl --request GET \
    --get "https://api.euronic.fi/api/v1/invoice/invoices" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.euronic.fi/api/v1/invoice/invoices"
);

const headers = {
    "Authorization": "Bearer {token}",
    "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.euronic.fi/api/v1/invoice/invoices',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.euronic.fi/api/v1/invoice/invoices'
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200):


{
   "message": "",
   "data": [
     {
       "id": 1,
       "ref_number": 11,
       "date": "2022-06-20",
       "due_date": "2022-07-20",
       "total": 154.6,
       "paid": false,
       "date_paid": null,
       "payment_method": null,
       "delivery_method": "e-invoice",
       "items": [
         {
           "description": "matti.fi rekisteröinnin uudistus 26.8.22-26.8.25",
           "qty": 1,
           "sub_total": 27,
           "total": 27,
           "tax_rate": 0
         },
         {
           "description": "matti.com rekisteröinnin uudistus 26.8.22-26.8.25",
           "qty": 1,
           "sub_total": 102.90,
           "total": 127.60,
           "tax_rate": 24
         }
       ],
       "recipient": {
         "company_name": "Matti&Maija OY",
         "business_id": "123456-7",
         "name": "Matti Meikäläinen",
         "address": "Esimerkkikatu 1",
         "zip_code": "20100",
         "city": "Turku",
         "country": "FI",
         "e_invoice_address": "",
         "e_invoice_intermediator": "",
       }
     },
     {
       "id": 2,
       "ref_number": 12,
       "date": "2022-08-01",
       "due_date": "2022-08-14",
       "total": 154.6,
       "paid": false,
       "date_paid": null,
       "payment_method": null,
       "delivery_method": "e-invoice",
       "items": [
         {
           "description": "maija.fi rekisteröinnin uudistus 26.8.22-26.8.25",
           "qty": 1,
           "sub_total": 27,
           "total": 27,
           "tax_rate": 0
         },
         {
           "description": "maija.com rekisteröinnin uudistus 26.8.22-26.8.25",
           "qty": 1,
           "sub_total": 102.90,
           "total": 127.60,
           "tax_rate": 24
         }
       ],
       "recipient": {
         "company_name": "Matti&Maija OY",
         "business_id": "123456-7",
         "name": "Maija Meikäläinen",
         "address": "Esimerkkikatu 1",
         "zip_code": "20100",
         "city": "Turku",
         "country": "FI",
         "e_invoice_address": "",
         "e_invoice_intermediator": "",
       }
     }
   ],
    "meta": {
       "limit": 100,
       "offset": 0,
       "count": 2,
       "total": 2
     }
}
 

Example response (401, Authorization token not provided or invalid):


{
  "error": {
    "status": 401,
    "message": "Unauthorized request",
  }
}
 

Request   

GET api/v1/invoice/invoices

Query Parameters

limit  integer optional  

the limit of results returned, only required with offset

offset  integer optional  

the offset of returned results, only required with limit

Response

Response Fields

id  integer  

Identier of the invoice

ref_number  string  

Reference number

date  string  

Date when invoice was created

due_date  string  

Due date of invoice

total  number  

Total amount of invoice

paid  boolean  

Whether invoice is paid or not

date_paid  string  

Date when invoice was paid

payment_method  string  

The method invoice was paid with

delivery_method  string  

The method invoice was delivered with (post, email, e-invoice)

items.description  string  

The description

items.qty  integer  

Quantity

items.sub_total  number  

Sub-total (VAT excluded)

items.total  number  

Total (VAT included)

items.tax_rate  integer  

Tax rate

recipient.company_name  string  

Company name

recipient.business_id  string  

Business ID

recipient.name  string  

Recipient name

recipient.address  string  

Address

recipient.zip_code    

Zip code

recipient.city  string  

City

recipient.country  string  

Two letter country code in ISO 639-1 format

recipient.e_invoice_address  string  

E-Invoice address

recipient.e_invoice_intermediator  string  

E-Invoice intermediator

meta.limit  integer  

The limit of results returned

meta.offset  integer  

The current offset of returned results

meta.count  integer  

Total number of items in the response

meta.total  integer  

Total number of items

Invoices - Retrieve details for the specified Invoice

requires authentication

Returns invoice data along with recipient information and invoice items

Example request:
curl --request GET \
    --get "https://api.euronic.fi/api/v1/invoice/invoices/1" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://api.euronic.fi/api/v1/invoice/invoices/1"
);

const headers = {
    "Authorization": "Bearer {token}",
    "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.euronic.fi/api/v1/invoice/invoices/1',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api.euronic.fi/api/v1/invoice/invoices/1'
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200):


{
   "message": "",
   "data": {
     "id": 1,
     "ref_number": 11,
     "date": "2022-06-20",
     "due_date": "2022-07-20",
     "total": 154.6,
     "paid": false,
     "date_paid": null,
     "payment_method": null,
     "delivery_method": "e-invoice",
     "items": [
       {
         "description": "matti.fi rekisteröinnin uudistus 26.8.22-26.8.25",
         "qty": 1,
         "sub_total": 27,
         "total": 27,
         "tax_rate": 0
       },
       {
         "description": "matti.com rekisteröinnin uudistus 26.8.22-26.8.25",
         "qty": 1,
         "sub_total": 102.90,
         "total": 127.60,
         "tax_rate": 24
       }
     ],
     "recipient": {
       "company_name": "Matti&Maija OY",
       "business_id": "123456-7",
       "name": "Matti Meikäläinen",
       "address": "Esimerkkikatu 1",
       "zip_code": "20100",
       "city": "Turku",
       "country": "FI",
       "e_invoice_address": "",
       "e_invoice_intermediator": "",
     }
   }
}
 

Example response (401, Authorization token not provided or invalid):


{
  "error": {
    "status": 401,
    "message": "Unauthorized request",
  }
}
 

Example response (403, Invoice is not assigned to the User):


{
  "error": {
    "status": 403,
    "message": "Forbidden request",
  }
}
 

Example response (404, Invoice does not exist):


{
  "error": {
    "status": 404,
    "message": "Resource not found",
  }
}
 

Request   

GET api/v1/invoice/invoices/{id}

URL Parameters

id  integer  

The requested invoice id

Response

Response Fields

id  integer  

Identier of the invoice

ref_number  string  

Reference number

date  string  

Date when invoice was created

due_date  string  

Due date of invoice

total  number  

Total amount of invoice

paid  boolean  

Whether invoice is paid or not

date_paid  string  

Date when invoice was paid

payment_method  string  

The method invoice was paid with

delivery_method  string  

The method invoice was delivered with (post, email, e-invoice)

items.description  string  

The description

items.qty  integer  

Quantity

items.sub_total  number  

Sub-total (VAT excluded)

items.total  number  

Total (VAT included)

items.tax_rate  integer  

Tax rate

recipient.company_name  string  

Company name

recipient.business_id  string  

Business ID

recipient.name  string  

Recipient name

recipient.address  string  

Address

recipient.zip_code    

Zip code

recipient.city  string  

City

recipient.country  string  

Two letter country code in ISO 639-1 format

recipient.e_invoice_address  string  

E-Invoice address

recipient.e_invoice_intermediator  string  

E-Invoice intermediator