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

# Validate policy configuration

POST https://api.lakera.ai/v2/policies/lint

Lint and validate policy JSON configuration files The easiest way to check your policy file validity is via the [policy linter tool in the Guard platform](https://platform.lakera.ai/policy-linter). This editor provides basic linting for your policy. It will check for common errors and provide suggestions for improvement.
The tool is run locally in the browser, so any policies or JSON entered in it are not saved anywhere. Note this also means that the contents are lost if you close the page.

Reference: https://docs.lakera.ai/api-reference/lakera-api/policies-linter/lint-policy

## Authentication

- `Authorization` header (bearer token, required) — Bearer authentication using API key. Generate an API key from the AI Guardrails Dashboard. Example: Bearer sk_123...

## Servers

- `https://api.lakera.ai` (Default, default)
- `https://eu.api.lakera.ai` (Eu)
- `https://us.api.lakera.ai` (Us)
- `https://ap-southeast-1.api.lakera.ai` (ApSoutheast)

## Response

### 200

Policy validation results

- `passed` (boolean, optional) — Whether validation passed
- `errors` (list of PolicyLintResponseErrorsItems, optional) — List of validation errors and warnings

## Types

### PolicyLintResponseErrorsItems

- `message` (string, optional) — Error or warning message
- `severity` (enum, optional) — Severity level of the issue
  - Allowed values: `error`, `warning`

## Examples

**Response**

```json
{
  "passed": true,
  "errors": [
    {
      "message": "string",
      "severity": "error"
    }
  ]
}
```

**SDK Code**

```python
import requests

url = "https://api.lakera.ai/v2/policies/lint"

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

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

print(response.json())
```

```javascript
const url = 'https://api.lakera.ai/v2/policies/lint';
const options = {method: 'POST', 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
package main

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

func main() {

	url := "https://api.lakera.ai/v2/policies/lint"

	req, _ := http.NewRequest("POST", 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
require 'uri'
require 'net/http'

url = URI("https://api.lakera.ai/v2/policies/lint")

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

request = Net::HTTP::Post.new(url)
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.post("https://api.lakera.ai/v2/policies/lint")
  .header("Authorization", "Bearer <token>")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.lakera.ai/v2/policies/lint', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

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

```csharp
using RestSharp;

var client = new RestClient("https://api.lakera.ai/v2/policies/lint");
var request = new RestRequest(Method.POST);
request.AddHeader("Authorization", "Bearer <token>");
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

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

let request = NSMutableURLRequest(url: NSURL(string: "https://api.lakera.ai/v2/policies/lint")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
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()
```