> 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.

# Retrieve terms and conditions acceptance

GET https://api.letsdeel.com/rest/organizations/terms-and-conditions

Returns the legal agreements of Deel's terms and conditions at their current version, with when the organization of the token accepted each one (null until it does), and the platform terms of service. `ACCEPTED` once every current agreement and the terms of service are accepted, `PENDING` otherwise. Use it to see what the accept endpoint will accept and to gate onboarding.

 **Token scopes**: `organizations:read`

 **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/organizations/retrieve-organization-terms-and-conditions-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

### Headers

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

## Response

### 200

The organization's terms and conditions acceptance.

- `data` (OrganizationsTermsAndConditionsGetResponsesContentApplicationJsonSchemaData, required) — The organization's terms and conditions acceptance.

## Errors

### 400 Bad Request Error

Operation failed.

- `errors` (list of OrganizationsTermsAndConditionsGetResponsesContentApplicationJsonSchemaErrorsItems, optional)

### 401 Unauthorized Error

Token missing or invalid.

- `code` (string, required)
- `error` (string, required)

### 403 Forbidden Error

Operation failed.

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

### 404 Not Found Error

Terms and conditions are not available for this organization.

- `code` (string, required)
- `error` (string, required)

### 500 Internal Server Error

Operation failed.

- `errors` (list of OrganizationsTermsAndConditionsGetResponsesContentApplicationJsonSchemaErrorsItems, optional)

### 503 Service Unavailable Error

The current terms could not be loaded. Safe to retry.

- `code` (string, required)
- `error` (string, required)

## Types

### OrganizationsTermsAndConditionsGetResponsesContentApplicationJsonSchemaData

The organization's terms and conditions acceptance.

- `status` (enum, required) — `ACCEPTED` once every legal agreement and the platform terms of service are accepted.
  - Allowed values: `ACCEPTED`, `PENDING`
- `agreements` (list of OrganizationsTermsAndConditionsGetResponsesContentApplicationJsonSchemaDataAgreementsItems, required) — The legal agreements (master service agreement pages) the organization must accept, at their current version.
- `accepted_at` (string, required, nullable) — Latest acceptance across the legal agreements and the terms of service; null when none.
- `terms_of_service` (OrganizationsTermsAndConditionsGetResponsesContentApplicationJsonSchemaDataTermsOfService, required, nullable) — The platform terms of service acceptance; null when not accepted.

### OrganizationsTermsAndConditionsGetResponsesContentApplicationJsonSchemaErrorsItems

- `code` (string, optional) — Machine-readable error code
- `message` (string, optional) — Human-readable explanation of the error

### 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

### OrganizationsTermsAndConditionsGetResponsesContentApplicationJsonSchemaDataAgreementsItems

- `title` (string, required, nullable) — Title of the legal agreement page, as published in the Deel Legal Hub.
- `version` (double, required) — Current version of the agreement page.
- `accepted_at` (string, required, nullable) — When this version of the agreement was accepted; null until it is accepted.

### OrganizationsTermsAndConditionsGetResponsesContentApplicationJsonSchemaDataTermsOfService

The platform terms of service acceptance; null when not accepted.

- `version` (string, required) — Version of the Deel platform terms of service.
- `accepted_at` (string, required) — When the platform terms of service were accepted.

## Examples

**Response**

```json
{
  "data": {
    "status": "ACCEPTED",
    "agreements": [
      {
        "title": "Master Service Agreement",
        "version": 42,
        "accepted_at": "2026-10-20T09:30:00.000Z"
      }
    ],
    "accepted_at": "2026-10-20T09:30:00.000Z",
    "terms_of_service": {
      "version": "v1",
      "accepted_at": "2026-10-20T09:30:00.000Z"
    }
  }
}
```

**SDK Code**

```python
import requests

url = "https://api.letsdeel.com/rest/organizations/terms-and-conditions"

headers = {
    "X-Beta": "true",
    "Authorization": "Bearer <token>"
}

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

print(response.json())
```

```javascript
const url = 'https://api.letsdeel.com/rest/organizations/terms-and-conditions';
const options = {method: 'GET', headers: {'X-Beta': 'true', Authorization: 'Bearer <token>'}};

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"
	"net/http"
	"io"
)

func main() {

	url := "https://api.letsdeel.com/rest/organizations/terms-and-conditions"

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

	req.Header.Add("X-Beta", "true")
	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
require 'uri'
require 'net/http'

url = URI("https://api.letsdeel.com/rest/organizations/terms-and-conditions")

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

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

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.get("https://api.letsdeel.com/rest/organizations/terms-and-conditions")
  .header("X-Beta", "true")
  .header("Authorization", "Bearer <token>")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.letsdeel.com/rest/organizations/terms-and-conditions', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
    'X-Beta' => 'true',
  ],
]);

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

```csharp
using RestSharp;

var client = new RestClient("https://api.letsdeel.com/rest/organizations/terms-and-conditions");
var request = new RestRequest(Method.GET);
request.AddHeader("X-Beta", "true");
request.AddHeader("Authorization", "Bearer <token>");
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = [
  "X-Beta": "true",
  "Authorization": "Bearer <token>"
]

let request = NSMutableURLRequest(url: NSURL(string: "https://api.letsdeel.com/rest/organizations/terms-and-conditions")! 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()
```