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

# Post Work Order Tasks Id Reviewers Reviewer Id Reminder

POST https://app.hindsiteind.com/api/v2/work_order_tasks/{id}/reviewers/{reviewer_id}/reminder

Emails the review request to a reviewer again and resets them to pending if they had already approved or rejected; only managers of the parent work order who did not contribute to the task's form may call it, and not to remind themselves.

Reference: https://api-docs.hindsiteind.com/hindsite-api/reviews/post-work-order-tasks-id-reviewers-reviewer-id-reminder

## Authentication

- `Authorization` header (bearer token, required) — OAuth 2.0 Client Credentials Flow. To obtain an access token: 1. Request API credentials from HINDSITE support to receive your `client_id` and `client_secret` 2. Make a POST request to obtain an access token: ``` POST https://app.hindsiteind.com/oauth/token Content-Type: application/x-www-form-urlencoded grant_type=client_credentials&client_id=YOUR_CLIENT_ID&client_secret=YOUR_CLIENT_SECRET ``` 3. The response will contain your access token: ```json { "access_token": "your_access_token_here", "token_type": "Bearer", "expires_in": 7200, "created_at": 1234567890 } ``` 4. Include the token in subsequent API requests: ``` Authorization: Bearer your_access_token_here ```

## Request

### Path parameters

- `id` (string, required)
- `reviewer_id` (string, required)

## Response

### 201

The reminded reviewer

- `id` (string, optional) — ULID
- `user` (User, optional) — The reviewer, including `last_active_at` and `archived`
- `reviewable_id` (string, optional) — ULID of the work order or work order task under review
- `reviewable_type` (enum, optional)
  - Allowed values: `WorkOrder`, `WorkOrderTask`
- `status` (enum, optional) — `pending` while awaiting a response (including after a reminder), `approved` or `rejected` once they respond, `commented` for someone who only commented without being asked to review
  - Allowed values: `pending`, `approved`, `rejected`, `commented`
- `requested_at` (datetime, optional, nullable) — When the review request was last emailed (ISO 8601); null if no request was emailed, such as someone who reviewed without being asked
- `stale` (boolean, optional) — true when the reviewer's latest approval or rejection is older than the latest change to the work
- `external` (boolean, optional) — true for an external (non-member) reviewer
- `remindable` (boolean, optional) — true when the caller can send this reviewer a reminder: they are not the caller, their access is not revoked, and they can receive email
- `removable` (boolean, optional) — true while the reviewer has not reviewed, so can be removed
- `revocable` (boolean, optional) — true for an external reviewer who has reviewed and whose access is not yet revoked
- `revocation` (ReviewerRevocation, optional, nullable) — null unless the reviewer's access has been revoked
- `reviews` (list of Review, optional) — Oldest first
- `created_at` (long, optional) — Unix timestamp (seconds since epoch)
- `updated_at` (long, optional) — Unix timestamp (seconds since epoch)

## Errors

### 403 Forbidden Error

Caller does not manage the parent work order, or contributed to the task's form

- `error` (string, optional)

### 404 Not Found Error

Work order task not found, or the caller cannot access it, or the reviewer does not belong to this work order task, or the reviewer is the caller

- `error` (string, optional)

### 422 Unprocessable Entity Error

The task is not completed, has no form, has active defects, or its work order is cancelled, or the reviewer can no longer be reminded (their access is revoked, external reviews have been turned off, or they cannot receive email, such as an archived user). The body carries an `error` message.

- `error` (string, optional)

## Types

### User

- `id` (string, optional) — ULID
- `email` (string, optional)
- `name` (string, optional)
- `is_admin` (boolean, optional)
- `location_manager` (boolean, optional)
- `last_active_at` (long, optional) — Unix timestamp (seconds since epoch)
- `archived` (boolean, optional)
- `organisation_id` (string, optional) — ULID
- `created_at` (long, optional) — Unix timestamp (seconds since epoch) when the record was created
- `updated_at` (long, optional) — Unix timestamp (seconds since epoch) when the record was last updated

### ReviewerRevocation

- `created_at` (datetime, optional) — When access was revoked (ISO 8601)
- `revoked_by` (User, optional, nullable) — The user who revoked access; null if that user no longer exists
- `updated_at` (long, optional) — Unix timestamp (seconds since epoch)

### Review

- `id` (string, optional) — ULID
- `status` (enum, optional)
  - Allowed values: `comment`, `approved`, `rejected`
- `comment` (string, optional, nullable) — null when the review was submitted without a comment
- `created_at` (datetime, optional) — ISO 8601
- `updated_at` (long, optional) — Unix timestamp (seconds since epoch)

## Examples

**Response**

```json
{
  "id": "string",
  "user": {
    "id": "string",
    "email": "string",
    "name": "string",
    "is_admin": true,
    "location_manager": true,
    "last_active_at": 1,
    "archived": true,
    "organisation_id": "string",
    "created_at": 1,
    "updated_at": 1
  },
  "reviewable_id": "string",
  "reviewable_type": "WorkOrder",
  "status": "pending",
  "requested_at": "2024-01-15T09:30:00Z",
  "stale": true,
  "external": true,
  "remindable": true,
  "removable": true,
  "revocable": true,
  "revocation": {
    "created_at": "2024-01-15T09:30:00Z",
    "revoked_by": {
      "id": "string",
      "email": "string",
      "name": "string",
      "is_admin": true,
      "location_manager": true,
      "last_active_at": 1,
      "archived": true,
      "organisation_id": "string",
      "created_at": 1,
      "updated_at": 1
    },
    "updated_at": 1
  },
  "reviews": [
    {
      "id": "string",
      "status": "comment",
      "comment": "string",
      "created_at": "2024-01-15T09:30:00Z",
      "updated_at": 1
    }
  ],
  "created_at": 1,
  "updated_at": 1
}
```

**SDK Code**

```python
import requests

url = "https://app.hindsiteind.com/api/v2/work_order_tasks/id/reviewers/reviewer_id/reminder"

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

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

print(response.json())
```

```javascript
const url = 'https://app.hindsiteind.com/api/v2/work_order_tasks/id/reviewers/reviewer_id/reminder';
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://app.hindsiteind.com/api/v2/work_order_tasks/id/reviewers/reviewer_id/reminder"

	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://app.hindsiteind.com/api/v2/work_order_tasks/id/reviewers/reviewer_id/reminder")

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://app.hindsiteind.com/api/v2/work_order_tasks/id/reviewers/reviewer_id/reminder")
  .header("Authorization", "Bearer <token>")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://app.hindsiteind.com/api/v2/work_order_tasks/id/reviewers/reviewer_id/reminder', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

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

```csharp
using RestSharp;

var client = new RestClient("https://app.hindsiteind.com/api/v2/work_order_tasks/id/reviewers/reviewer_id/reminder");
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://app.hindsiteind.com/api/v2/work_order_tasks/id/reviewers/reviewer_id/reminder")! 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()
```