> 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://docs.deel.wtf/api/stable/llms.txt

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

# Validate offer terms for an application

POST https://api.letsdeel.com/rest/ats/applications/{application_id}/offer-validations
Content-Type: application/json

Checks proposed offer terms against Deel's hiring rules for the worker type and country before the offer is created, so problems surface while the terms can still change. Call it before `POST /rest/ats/applications/{application_id}/offers`. Nothing is saved.

**Token scopes**: `ats:write`, `worker:write`

**Beta**: this version requires the `X-Beta: true` request header and its contract may change before it is promoted to stable. It is scheduled to become stable on 2027-01-29.

Reference: https://docs.deel.wtf/api/reference/endpoints/ats/validate-offer-terms-for-application-v-2026-10-29

## 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.deel.training/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

- `application_id` (string, required) — ID of the application the offer is for

### Headers

- `X-Beta` (enum, required, default: true) — Opts in to the beta version of this endpoint. Must be `true`.
  - Allowed values: `true`

### Body (application/json)

This endpoint expects an object.

- `data` (AtsApplicationsApplicationIdOfferValidationsPostRequestBodyContentApplicationJsonSchemaData, required)

## Response

### 200

Terms checked

- `data` (AtsApplicationsApplicationIdOfferValidationsPostResponsesContentApplicationJsonSchemaData, required) — Outcome of the validation

## Errors

### 400 Bad Request Error

Operation failed.

- `errors` (list of AtsApplicationsApplicationIdOfferValidationsPostResponsesContentApplicationJsonSchemaErrorsItems, required) — List of error objects

### 401 Unauthorized Error

Operation failed.

- `request` (ApiErrorRequest, optional)
- `errors` (list of ApiError, optional)

### 403 Forbidden Error

Forbidden. ATS is not enabled for this organization or insufficient permissions.

- `errors` (list of AtsApplicationsApplicationIdOfferValidationsPostResponsesContentApplicationJsonSchemaErrorsItems, required) — List of error objects

### 404 Not Found Error

Not found, or not visible to the authenticated user. The two cases are indistinguishable.

- `errors` (list of AtsApplicationsApplicationIdOfferValidationsPostResponsesContentApplicationJsonSchemaErrorsItems, required) — List of error objects

### 500 Internal Server Error

Operation failed.

- `errors` (list of AtsApplicationsApplicationIdOfferValidationsPostResponsesContentApplicationJsonSchemaErrorsItems, required) — List of error objects

### 502 Bad Gateway Error

Bad gateway. The hiring rules service could not be reached, so the terms were not checked.

- `errors` (list of AtsApplicationsApplicationIdOfferValidationsPostResponsesContentApplicationJsonSchemaErrorsItems, required) — List of error objects

## Types

### AtsApplicationsApplicationIdOfferValidationsPostRequestBodyContentApplicationJsonSchemaData

- `start_date` (string, required) — Proposed start date of the candidate
- `worker_type` (enum, required) — How the candidate will be hired
  - Allowed values: `CONTRACTOR_FIXED`, `CONTRACTOR_PAY_AS_YOU_GO`, `CONTRACTOR_MILESTONE`, `DIRECT_EMPLOYEE`, `EOR_EMPLOYEE`, `GLOBAL_PAYROLL_EMPLOYEE`, `PEO_EMPLOYEE`, `PWAC`
- `country_code` (string, required) — ISO 3166-1 alpha-2 code of the country the candidate will work in
- `compensation_amount` (double, required) — Compensation amount for the period
- `compensation_currency` (string, required) — ISO 4217 currency code of the compensation
- `state` (string, optional, nullable) — State or region code within the country, where the rules depend on it
- `job_title` (string, optional, nullable) — Job title offered to the candidate
- `compensation_period_slug` (enum, optional) — Period the compensation amount covers
  - Allowed values: `annually`, `monthly`, `semimonthly`, `biweekly`, `weekly`, `daily`, `hourly`

### AtsApplicationsApplicationIdOfferValidationsPostResponsesContentApplicationJsonSchemaData

Outcome of the validation

- `errors` (list of AtsApplicationsApplicationIdOfferValidationsPostResponsesContentApplicationJsonSchemaDataErrorsItems, required) — Rules the terms break; empty when the terms are valid
- `is_valid` (boolean, required) — Whether the terms satisfy every rule

### AtsApplicationsApplicationIdOfferValidationsPostResponsesContentApplicationJsonSchemaErrorsItems

- `code` (string, required) — Machine-readable error code
- `message` (string, required) — Human-readable error message
- `field` (string, optional) — Request field related to the error, if applicable

### ApiErrorRequest

- `method` (string, optional) — The HTTP method of the failed request
- `url` (string, optional) — The relative URL of the failed request
- `status` (double, optional) — The status code of the response
- `api_req_id` (string, optional) — The request ID of the failed request
- `docs` (string, optional) — A link to the official documentation for the requested endpoint resource
- `source` (string, optional) — The source handler which produced the returned error
- `code` (double, optional) — The code of the source handler which produced the returned error

### ApiError

- `message` (string, optional) — A description of the returned error
- `path` (string, optional) — The JSON path where input validation failed

### AtsApplicationsApplicationIdOfferValidationsPostResponsesContentApplicationJsonSchemaDataErrorsItems

- `code` (string, required) — Machine-readable code of the broken rule
- `field` (string, required, nullable) — Request field the error is about, or null when it concerns the terms as a whole
- `message` (string, required) — Explanation of the broken rule to show to the user

## Examples

**Request**

```json
{
  "data": {
    "start_date": "2026-12-01T00:00:00Z",
    "worker_type": "EOR_EMPLOYEE",
    "country_code": "US",
    "compensation_amount": 85000,
    "compensation_currency": "USD"
  }
}
```

**Response**

```json
{
  "data": {
    "errors": [
      {
        "code": "MINIMUM_WAGE",
        "field": "compensation_amount",
        "message": "The compensation is below the minimum wage for this country."
      }
    ],
    "is_valid": false
  }
}
```

**SDK Code**

```python
import requests

url = "https://api.letsdeel.com/rest/ats/applications/faac641e-a484-4875-aed5-bfcb0a0691a0/offer-validations"

payload = { "data": {
        "start_date": "2026-12-01T00:00:00Z",
        "worker_type": "EOR_EMPLOYEE",
        "country_code": "US",
        "compensation_amount": 85000,
        "compensation_currency": "USD"
    } }
headers = {
    "X-Beta": "true",
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
```

```javascript
const url = 'https://api.letsdeel.com/rest/ats/applications/faac641e-a484-4875-aed5-bfcb0a0691a0/offer-validations';
const options = {
  method: 'POST',
  headers: {
    'X-Beta': 'true',
    Authorization: 'Bearer <token>',
    'Content-Type': 'application/json'
  },
  body: '{"data":{"start_date":"2026-12-01T00:00:00Z","worker_type":"EOR_EMPLOYEE","country_code":"US","compensation_amount":85000,"compensation_currency":"USD"}}'
};

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

```go
package main

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

func main() {

	url := "https://api.letsdeel.com/rest/ats/applications/faac641e-a484-4875-aed5-bfcb0a0691a0/offer-validations"

	payload := strings.NewReader("{\n  \"data\": {\n    \"start_date\": \"2026-12-01T00:00:00Z\",\n    \"worker_type\": \"EOR_EMPLOYEE\",\n    \"country_code\": \"US\",\n    \"compensation_amount\": 85000,\n    \"compensation_currency\": \"USD\"\n  }\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("X-Beta", "true")
	req.Header.Add("Authorization", "Bearer <token>")
	req.Header.Add("Content-Type", "application/json")

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

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

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

}
```

```ruby
require 'uri'
require 'net/http'

url = URI("https://api.letsdeel.com/rest/ats/applications/faac641e-a484-4875-aed5-bfcb0a0691a0/offer-validations")

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

request = Net::HTTP::Post.new(url)
request["X-Beta"] = 'true'
request["Authorization"] = 'Bearer <token>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"data\": {\n    \"start_date\": \"2026-12-01T00:00:00Z\",\n    \"worker_type\": \"EOR_EMPLOYEE\",\n    \"country_code\": \"US\",\n    \"compensation_amount\": 85000,\n    \"compensation_currency\": \"USD\"\n  }\n}"

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

```java
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://api.letsdeel.com/rest/ats/applications/faac641e-a484-4875-aed5-bfcb0a0691a0/offer-validations")
  .header("X-Beta", "true")
  .header("Authorization", "Bearer <token>")
  .header("Content-Type", "application/json")
  .body("{\n  \"data\": {\n    \"start_date\": \"2026-12-01T00:00:00Z\",\n    \"worker_type\": \"EOR_EMPLOYEE\",\n    \"country_code\": \"US\",\n    \"compensation_amount\": 85000,\n    \"compensation_currency\": \"USD\"\n  }\n}")
  .asString();
```

```php
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.letsdeel.com/rest/ats/applications/faac641e-a484-4875-aed5-bfcb0a0691a0/offer-validations', [
  'body' => '{
  "data": {
    "start_date": "2026-12-01T00:00:00Z",
    "worker_type": "EOR_EMPLOYEE",
    "country_code": "US",
    "compensation_amount": 85000,
    "compensation_currency": "USD"
  }
}',
  'headers' => [
    'Authorization' => 'Bearer <token>',
    'Content-Type' => 'application/json',
    'X-Beta' => 'true',
  ],
]);

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

```csharp
using RestSharp;

var client = new RestClient("https://api.letsdeel.com/rest/ats/applications/faac641e-a484-4875-aed5-bfcb0a0691a0/offer-validations");
var request = new RestRequest(Method.POST);
request.AddHeader("X-Beta", "true");
request.AddHeader("Authorization", "Bearer <token>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"data\": {\n    \"start_date\": \"2026-12-01T00:00:00Z\",\n    \"worker_type\": \"EOR_EMPLOYEE\",\n    \"country_code\": \"US\",\n    \"compensation_amount\": 85000,\n    \"compensation_currency\": \"USD\"\n  }\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = [
  "X-Beta": "true",
  "Authorization": "Bearer <token>",
  "Content-Type": "application/json"
]
let parameters = ["data": [
    "start_date": "2026-12-01T00:00:00Z",
    "worker_type": "EOR_EMPLOYEE",
    "country_code": "US",
    "compensation_amount": 85000,
    "compensation_currency": "USD"
  ]] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://api.letsdeel.com/rest/ats/applications/faac641e-a484-4875-aed5-bfcb0a0691a0/offer-validations")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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()
```