> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.itential.com/itential-cloud/api-reference/lifecycle-manager/validate-actions-http/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.itential.com/_mcp/server.

# Validate the actions defined on a resource model

POST https://example.itential.io/lifecycle-manager/resources/{modelId}/actions/validate
Content-Type: application/json

This method validates the actions on a resource model. Each validation report has an associate severity, and designates whether or not it will prevent the action from saving, prevent the model from running, or both. It accepts pending edits to actions in the optional 'actions' body parameter in order to check for validation issues on unsaved, pending changes to an action.

Reference: https://docs.itential.com/itential-cloud/api-reference/lifecycle-manager/validate-actions-http

## Authentication

- `Authorization` header (basic auth, required) — Basic authentication of the form `Basic <base64(username:password)>`.

## Request

### Path parameters

- `modelId` (string, required) — Resource model ID

### Body (application/json)

This endpoint expects an object.

- `actions` (list of object, optional)
  - `_id` (any, required) — The identifier of an action
  - `name` (string, required) — The name of the action
  - `type` (enum, required) — The type of the action
    - Allowed values: `import`, `create`, `update`, `delete`
  - `preWorkflowJst` (string, required, nullable) — Optional transformation to be applied to incoming parameters before providing them to the workflow.
  - `workflow` (string, required, nullable) — Optional transformation to be applied to incoming parameters before providing them to the workflow.
  - `postWorkflowJst` (string, required, nullable) — Optional transformation to be applied to the workflow's outputs before updating the instance.
  - `description` (string, optional, default: ) — Free-form text describing the purpose of the action

## Response

### 200

response

- `object or object`
  - object
    - `message` (string, required) — A human-readable message summarizing the result of the operation
    - `data` (any, required) — Any successfully retrieved information related to the request.
    - `metadata` (map from string to any, required) — Any structured, wordy or machine-readable information related to the result of the operation. For success responses, this may contain information like pagination values from a search operation.
  - object
    - `message` (string, required) — A human-readable message summarizing the result of the operation
    - `data` (any, required) — Any successfully retrieved information related to the request. For error responses, this is always 'null'.
    - `metadata` (object, required) — Any structured, wordy or machine-readable information related to the result of the operation. For error responses, this will always at least contain an 'errors' array, even if it is empty.
      - `errors` (list of any, optional)

## Errors

### 500 Internal Server Error

Error response from API

- `any`

## Examples

**Request**

```json
{}
```

**Response**

```json
{
  "data": null,
  "message": "Successfully created the requested item",
  "metadata": {}
}
```

**SDK Code**

```python
import requests

url = "https://example.itential.io/lifecycle-manager/resources/modelId/actions/validate"

payload = {}
headers = {"Content-Type": "application/json"}

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

print(response.json())
```

```javascript
const url = 'https://example.itential.io/lifecycle-manager/resources/modelId/actions/validate';
const options = {method: 'POST', headers: {'Content-Type': 'application/json'}, body: '{}'};

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://example.itential.io/lifecycle-manager/resources/modelId/actions/validate"

	payload := strings.NewReader("{}")

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

	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://example.itential.io/lifecycle-manager/resources/modelId/actions/validate")

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

request = Net::HTTP::Post.new(url)
request["Content-Type"] = 'application/json'
request.body = "{}"

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://example.itential.io/lifecycle-manager/resources/modelId/actions/validate")
  .header("Content-Type", "application/json")
  .body("{}")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://example.itential.io/lifecycle-manager/resources/modelId/actions/validate', [
  'body' => '{}',
  'headers' => [
    'Content-Type' => 'application/json',
  ],
]);

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

```csharp
using RestSharp;

var client = new RestClient("https://example.itential.io/lifecycle-manager/resources/modelId/actions/validate");
var request = new RestRequest(Method.POST);
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = ["Content-Type": "application/json"]
let parameters = [] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "https://example.itential.io/lifecycle-manager/resources/modelId/actions/validate")! 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()
```