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

# Create a work statement payment policy

POST https://api.letsdeel.com/rest/work-statement-payment-policies
Content-Type: application/json

Use this endpoint to define a payment cycle once and reuse it, rather than repeating the same cycle fields on every contract you create. The returned policy ID can be referenced when creating contracts. Both the policy name and the combination of cycle settings must be unique within the organization.


 **Token scopes**: `contracts:write`

Reference: https://developer.deel.com/api/reference/endpoints/contracts/create-work-statement-payment-policy-v-2026-09-07

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

### Body (application/json)

This endpoint expects an object.

- `data` (WorkStatementPaymentPoliciesPostRequestBodyContentApplicationJsonSchemaData, required)

## Response

### 201

The work statement payment policy was created.

- `data` (WorkStatementPaymentPoliciesPostResponsesContentApplicationJsonSchemaData, required) — The created work statement payment policy.

## Errors

### 400 Bad Request Error

Operation failed.

- `errors` (list of WorkStatementPaymentPoliciesPostResponsesContentApplicationJsonSchemaErrorsItems, optional)

### 401 Unauthorized Error

Operation failed.

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

### 403 Forbidden Error

Operation failed.

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

### 404 Not Found Error

Operation failed.

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

### 500 Internal Server Error

Operation failed.

- `errors` (list of WorkStatementPaymentPoliciesPostResponsesContentApplicationJsonSchemaErrorsItems, optional)

## Types

### WorkStatementPaymentPoliciesPostRequestBodyContentApplicationJsonSchemaData

- `name` (string, required) — Name of the payment policy. Must be unique within the organization.
- `scale` (enum, required) — Payment cycle frequency.
  - Allowed values: `WEEKLY`, `MONTHLY`, `BIWEEKLY`, `SEMIMONTHLY`, `CALENDAR_MONTH`
- `end_day` (integer, required) — Day the billing cycle ends. 1–31 when end_type is DAY_OF_MONTH, 1–7 when DAY_OF_WEEK or DAY_OF_LAST_WEEK.
- `due_days` (integer, optional) — Number of days after cycle end before payment is released. Defaults to 0.
- `due_type` (enum, optional) — How the payment due date is calculated relative to cycle end. Defaults to REGULAR.
  - Allowed values: `REGULAR`, `WITHIN_MONTH`, `AFTER_MONTH`, `BEFORE_CYCLE_END`
- `end_type` (enum, optional) — How end_day is interpreted. Defaults to DAY_OF_MONTH.
  - Allowed values: `DAY_OF_WEEK`, `DAY_OF_LAST_WEEK`, `DAY_OF_MONTH`
- `description` (string, optional) — Description of the payment policy.
- `end_week_parity` (enum, optional) — Week parity constraint for biweekly cycles. Only applicable when scale is BIWEEKLY.
  - Allowed values: `AUTO`, `ODD`, `EVEN`
- `should_pay_before_weekends` (boolean, optional) — Whether payment is moved earlier when the due date falls on a weekend. Defaults to false.

### WorkStatementPaymentPoliciesPostResponsesContentApplicationJsonSchemaData

The created work statement payment policy.

- `id` (string, required) — The public ID (UUID) of the created payment policy.

### WorkStatementPaymentPoliciesPostResponsesContentApplicationJsonSchemaErrorsItems

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

## Examples

**Request**

```json
{
  "data": {
    "name": "Monthly policy - Fixed rate",
    "scale": "MONTHLY",
    "end_day": 31
  }
}
```

**Response**

```json
{
  "data": {
    "id": "00000000-0000-0000-0000-000000000000"
  }
}
```

**SDK Code**

```python
import requests

url = "https://api.letsdeel.com/rest/work-statement-payment-policies"

payload = { "data": {
        "name": "Monthly policy - Fixed rate",
        "scale": "MONTHLY",
        "end_day": 31
    } }
headers = {
    "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/work-statement-payment-policies';
const options = {
  method: 'POST',
  headers: {Authorization: 'Bearer <token>', 'Content-Type': 'application/json'},
  body: '{"data":{"name":"Monthly policy - Fixed rate","scale":"MONTHLY","end_day":31}}'
};

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/work-statement-payment-policies"

	payload := strings.NewReader("{\n  \"data\": {\n    \"name\": \"Monthly policy - Fixed rate\",\n    \"scale\": \"MONTHLY\",\n    \"end_day\": 31\n  }\n}")

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

	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/work-statement-payment-policies")

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

request = Net::HTTP::Post.new(url)
request["Authorization"] = 'Bearer <token>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"data\": {\n    \"name\": \"Monthly policy - Fixed rate\",\n    \"scale\": \"MONTHLY\",\n    \"end_day\": 31\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/work-statement-payment-policies")
  .header("Authorization", "Bearer <token>")
  .header("Content-Type", "application/json")
  .body("{\n  \"data\": {\n    \"name\": \"Monthly policy - Fixed rate\",\n    \"scale\": \"MONTHLY\",\n    \"end_day\": 31\n  }\n}")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.letsdeel.com/rest/work-statement-payment-policies', [
  'body' => '{
  "data": {
    "name": "Monthly policy - Fixed rate",
    "scale": "MONTHLY",
    "end_day": 31
  }
}',
  'headers' => [
    'Authorization' => 'Bearer <token>',
    'Content-Type' => 'application/json',
  ],
]);

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

```csharp
using RestSharp;

var client = new RestClient("https://api.letsdeel.com/rest/work-statement-payment-policies");
var request = new RestRequest(Method.POST);
request.AddHeader("Authorization", "Bearer <token>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"data\": {\n    \"name\": \"Monthly policy - Fixed rate\",\n    \"scale\": \"MONTHLY\",\n    \"end_day\": 31\n  }\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = [
  "Authorization": "Bearer <token>",
  "Content-Type": "application/json"
]
let parameters = ["data": [
    "name": "Monthly policy - Fixed rate",
    "scale": "MONTHLY",
    "end_day": 31
  ]] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "https://api.letsdeel.com/rest/work-statement-payment-policies")! 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()
```