> This page is for API, version 2026-01-01 (Stable) (default).
> For other versions, use one of these documentation indexes:
> - 2026-01-01 (Stable) (default): https://developer.deel.com/api/stable/llms.txt

> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://developer.deel.com/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://developer.deel.com/_mcp/server.

# Retrieve employee additional info template

GET https://api.letsdeel.com/rest/employee-info/contract-types/{type}/countries/{country}

Retrieves the template describing which additional information fields must be collected for a worker on a given contract type in a given country. Use this endpoint when building or validating an onboarding form so the correct country- and contract-type-specific fields are requested before submitting employee information.

 **Token scopes**: `contracts:read`

Reference: https://developer.deel.com/api/reference/endpoints/employee-information/employee-additional-info-template-v-2026-01-01

## Authentication

- `Authorization` header (bearer token, required) — ## Authentication The Deel API uses bearer tokens to authenticate requests. All API calls must be made over HTTPS — calls over plain HTTP or without authentication will fail. ```curl curl -X GET 'https://api.letsdeel.com/rest/v2/contracts' \ -H 'Authorization: Bearer YOUR-TOKEN-HERE' ``` [Learn more about authentication](/api/authentication)
- `Authorization` header (bearer token, required) — Standard OAuth2 security scheme based on https://swagger.io/docs/specification/authentication/

## Servers

- `https://api.letsdeel.com/rest` (Production, default)
- `https://api-staging.letsdeel.com/rest` (Demo)

## Request

### Path parameters

- `type` (enum, required) — The contract type. Must be 'eor' (Employer of Record) or 'gp' (Global Payroll).
  - Allowed values: `eor`, `gp`
- `country` (string, required) — ISO 3166-1 alpha-2 country code.

## Response

### 200

Successful operation.

- `data` (list of EmployeeInfoContractTypesTypeCountriesCountryGetResponsesContentApplicationJsonSchemaDataItems, optional)

## Errors

### 400 Bad Request Error

Invalid country code or contract type.

### 401 Unauthorized Error

Authentication failed. The access token is missing, expired, or invalid.

- `errors` (list of EmployeeInfoContractTypesTypeCountriesCountryGetResponsesContentApplicationJsonSchemaErrorsItems, required)

### 403 Forbidden Error

Access denied. The authenticated user does not have the required contracts:read scope or contracts.view permission.

- `errors` (list of EmployeeInfoContractTypesTypeCountriesCountryGetResponsesContentApplicationJsonSchemaErrorsItems, required)

### 404 Not Found Error

No additional info template exists for the given country and contract type combination in the Employee Data Management system.

- `errors` (list of EmployeeInfoContractTypesTypeCountriesCountryGetResponsesContentApplicationJsonSchemaErrorsItems, required)

### 429 Too Many Requests Error

Rate limit exceeded. The client has sent too many requests in a given time window.

- `errors` (list of EmployeeInfoContractTypesTypeCountriesCountryGetResponsesContentApplicationJsonSchemaErrorsItems, required)

### 500 Internal Server Error

Internal server error. Returned when the Employee Data Management service is unreachable or an unexpected error occurs.

- `errors` (list of EmployeeInfoContractTypesTypeCountriesCountryGetResponsesContentApplicationJsonSchemaErrorsItems, required)

## Types

### EmployeeInfoContractTypesTypeCountriesCountryGetResponsesContentApplicationJsonSchemaDataItems

- `id` (string, optional) — Unique identifier for the field
- `name` (string, optional) — Name of the field
- `alias` (string, optional) — Alias for the field
- `label` (string, optional) — Label for the field
- `options` (list of string, optional, nullable) — Options for select input type
- `footnote` (string, optional, nullable) — Footnote for the field
- `input_type` (string, optional) — Type of input for the field
- `local_name` (string, optional, nullable) — Local name for the field
- `description` (string, optional, nullable) — Description of the field
- `is_optional` (boolean, optional) — Indicates if the field is optional
- `required_by` (string, optional) — Specifies when the field is required
- `dependencies` (list of EmployeeInfoContractTypesTypeCountriesCountryGetResponsesContentApplicationJsonSchemaDataItemsDependenciesItems, optional, nullable) — Dependencies for the field
- `display_order` (string, optional, nullable) — Display order of the field
- `how_to_obtain` (string, optional, nullable) — Instructions on how to obtain the field value
- `can_be_skipped` (boolean, optional, nullable) — Indicates if the field can be skipped
- `link_to_obtain` (string, optional, nullable) — Link to obtain the field value
- `validation_rule` (string, optional, nullable) — Validation rule for the field
- `input_configuration` (EmployeeInfoContractTypesTypeCountriesCountryGetResponsesContentApplicationJsonSchemaDataItemsInputConfiguration, optional, nullable) — Configuration object for the input field. Present for input types that require additional format or display configuration, such as date fields.
- `link_to_obtain_label` (string, optional, nullable) — Label for the link to obtain the field value
- `validation_error_message` (string, optional, nullable) — Validation error message for the field
- `dependency_condition_match_mode` (enum, optional, nullable) — Condition match mode for dependencies
  - Allowed values: `ALL`, `ANY`

### EmployeeInfoContractTypesTypeCountriesCountryGetResponsesContentApplicationJsonSchemaErrorsItems

- `message` (string, required) — Use this message for logging and debugging purposes. Contains a general error description.

### EmployeeInfoContractTypesTypeCountriesCountryGetResponsesContentApplicationJsonSchemaDataItemsDependenciesItems

- `id` (string, optional) — ID of the dependency
- `value` (EmployeeInfoContractTypesTypeCountriesCountryGetResponsesContentApplicationJsonSchemaDataItemsDependenciesItemsValue, optional) — Value the parent field is compared against. A bare scalar or array implies equality (membership for arrays); the object form specifies an explicit comparison operator, and requires value for every operator except notnull.

### EmployeeInfoContractTypesTypeCountriesCountryGetResponsesContentApplicationJsonSchemaDataItemsInputConfiguration

Configuration object for the input field. Present for input types that require additional format or display configuration, such as date fields.

- `type` (string, optional) — The configuration type matching the input type
- `format` (EmployeeInfoContractTypesTypeCountriesCountryGetResponsesContentApplicationJsonSchemaDataItemsInputConfigurationFormat, optional) — Format configuration for the input

### EmployeeInfoContractTypesTypeCountriesCountryGetResponsesContentApplicationJsonSchemaDataItemsDependenciesItemsValue

Value the parent field is compared against. A bare scalar or array implies equality (membership for arrays); the object form specifies an explicit comparison operator, and requires value for every operator except notnull.

### EmployeeInfoContractTypesTypeCountriesCountryGetResponsesContentApplicationJsonSchemaDataItemsInputConfigurationFormat

Format configuration for the input

- `pattern` (string, optional) — Date format pattern
- `separator` (string, optional) — Separator character for the format

## Examples

**Response**

```json
{
  "data": [
    {
      "id": "b7045ecb-c5ca-43fa-99f-61bcb700ee89",
      "name": "idType",
      "alias": "deel_additional-data_es_id-type",
      "label": "ID Type",
      "options": [
        "Passport",
        "National ID"
      ],
      "footnote": null,
      "input_type": "select",
      "local_name": "Tipo de identificacion",
      "description": "Select your identification type",
      "is_optional": false,
      "required_by": "sign_up",
      "display_order": "1",
      "how_to_obtain": null,
      "can_be_skipped": false,
      "link_to_obtain": null,
      "validation_rule": "^(Passport|National ID)$",
      "input_configuration": null,
      "link_to_obtain_label": null,
      "validation_error_message": "Must be one of the following values: Passport, National ID"
    },
    {
      "id": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
      "name": "idNumber",
      "alias": "deel_additional-data_es_id-number",
      "label": "ID Number",
      "footnote": null,
      "input_type": "text",
      "local_name": "Numero de identificacion",
      "description": "Enter your identification number",
      "is_optional": false,
      "required_by": "sign_up",
      "dependencies": [
        {
          "id": "b7045ecb-c5ca-43fa-99f-61bcb700ee89",
          "value": "National ID"
        }
      ],
      "display_order": "2",
      "how_to_obtain": null,
      "can_be_skipped": false,
      "link_to_obtain": null,
      "validation_rule": "^[A-Z0-9]+$",
      "input_configuration": null,
      "link_to_obtain_label": null,
      "validation_error_message": "Must contain only uppercase letters and numbers",
      "dependency_condition_match_mode": "ALL"
    }
  ]
}
```

**SDK Code**

```python Employee Information_employeeAdditionalInfoTemplate-v2026-01-01_example
import requests

url = "https://api.letsdeel.com/rest/employee-info/contract-types/eor/countries/ES"

headers = {"Authorization": "Bearer <token>"}

response = requests.get(url, headers=headers)

print(response.json())
```

```javascript Employee Information_employeeAdditionalInfoTemplate-v2026-01-01_example
const url = 'https://api.letsdeel.com/rest/employee-info/contract-types/eor/countries/ES';
const options = {method: 'GET', headers: {Authorization: 'Bearer <token>'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go Employee Information_employeeAdditionalInfoTemplate-v2026-01-01_example
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://api.letsdeel.com/rest/employee-info/contract-types/eor/countries/ES"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("Authorization", "Bearer <token>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby Employee Information_employeeAdditionalInfoTemplate-v2026-01-01_example
require 'uri'
require 'net/http'

url = URI("https://api.letsdeel.com/rest/employee-info/contract-types/eor/countries/ES")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Authorization"] = 'Bearer <token>'

response = http.request(request)
puts response.read_body
```

```java Employee Information_employeeAdditionalInfoTemplate-v2026-01-01_example
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://api.letsdeel.com/rest/employee-info/contract-types/eor/countries/ES")
  .header("Authorization", "Bearer <token>")
  .asString();
```

```php Employee Information_employeeAdditionalInfoTemplate-v2026-01-01_example
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.letsdeel.com/rest/employee-info/contract-types/eor/countries/ES', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

echo $response->getBody();
```

```csharp Employee Information_employeeAdditionalInfoTemplate-v2026-01-01_example
using RestSharp;

var client = new RestClient("https://api.letsdeel.com/rest/employee-info/contract-types/eor/countries/ES");
var request = new RestRequest(Method.GET);
request.AddHeader("Authorization", "Bearer <token>");
IRestResponse response = client.Execute(request);
```

```swift Employee Information_employeeAdditionalInfoTemplate-v2026-01-01_example
import Foundation

let headers = ["Authorization": "Bearer <token>"]

let request = NSMutableURLRequest(url: NSURL(string: "https://api.letsdeel.com/rest/employee-info/contract-types/eor/countries/ES")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```