> 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 Orders Id Reviewers Reviewer Id Reminder

POST https://app.hindsiteind.com/api/v2/work_orders/{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 admins, the work order's assigned managers and leads, location managers and its creator may call it, and not to remind themselves.

Reference: https://api-docs.hindsiteind.com/hindsite-api/reviews/post-work-orders-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 work order

- `error` (string, optional)

### 404 Not Found Error

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

- `error` (string, optional)

### 422 Unprocessable Entity Error

The work order is not completed, or 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_orders/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_orders/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_orders/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_orders/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_orders/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_orders/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_orders/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_orders/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()
```