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

# Put Work Orders Id Notes Note Id

PUT https://app.hindsiteind.com/api/v2/work_orders/{id}/notes/{note_id}
Content-Type: application/json

Replaces the content of one of the caller's own notes on a work order the caller can see; a note written by anyone else returns 404, even for admins.

Reference: https://api-docs.hindsiteind.com/hindsite-api/notes/put-work-orders-id-notes-note-id

## 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)
- `note_id` (string, required)

### Body (application/json)

This endpoint expects a putV2WorkOrdersIdNotesNoteId.

- `content` (string, required) — The note body as rich-text HTML. Replaces the whole body; there is no partial update.

## Response

### 200

updated Note

- `id` (string, optional) — ULID
- `content` (string, optional) — Sanitized HTML content
- `plain_text_content` (string, optional)
- `user` (User, optional)
- `noteable_type` (string, optional)
- `noteable_id` (string, optional) — ULID
- `attachments` (list of ActiveStorageBlob, optional)
- `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

## Errors

### 404 Not Found Error

The work order does not exist or the caller cannot see it, or the note is not on this work order or was written by someone else. 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

### ActiveStorageBlob

- `blob_url` (string, optional)
- `signed_id` (string, optional)
- `filename` (string, optional)
- `byte_size` (integer, optional)
- `content_type` (string, optional)
- `preview_url` (string, optional) — Poster image URL. Present only for previewable blobs (e.g. video).
- `key` (string, optional) — Storage key of the file in Hindsite's file store. Opaque; download the file with blob_url.
- `direct_upload` (ActiveStorageBlobDirectUpload, optional) — Only present on the POST /api/v2/active_storage/presign and POST /api/v2/active_storage/direct_uploads responses, which omit preview_url. PUT the file bytes to url with headers, then reference the blob by signed_id.

### ActiveStorageBlobDirectUpload

Only present on the POST /api/v2/active_storage/presign and POST /api/v2/active_storage/direct_uploads responses, which omit preview_url. PUT the file bytes to url with headers, then reference the blob by signed_id.

- `url` (string, optional) — Pre-signed upload URL, valid for 30 minutes
- `headers` (map from string to string, optional) — HTTP headers to send with the upload, such as Content-Type and Content-MD5

## Examples

**Request**

```json
{
  "content": "string"
}
```

**Response**

```json
{
  "id": "string",
  "content": "string",
  "plain_text_content": "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
  },
  "noteable_type": "string",
  "noteable_id": "string",
  "attachments": [
    {
      "blob_url": "string",
      "signed_id": "string",
      "filename": "string",
      "byte_size": 1,
      "content_type": "string",
      "preview_url": "string",
      "key": "string",
      "direct_upload": {
        "url": "string",
        "headers": {}
      }
    }
  ],
  "created_at": 1,
  "updated_at": 1
}
```

**SDK Code**

```python
import requests

url = "https://app.hindsiteind.com/api/v2/work_orders/id/notes/note_id"

payload = { "content": "string" }
headers = {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
}

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

print(response.json())
```

```javascript
const url = 'https://app.hindsiteind.com/api/v2/work_orders/id/notes/note_id';
const options = {
  method: 'PUT',
  headers: {Authorization: 'Bearer <token>', 'Content-Type': 'application/json'},
  body: '{"content":"string"}'
};

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://app.hindsiteind.com/api/v2/work_orders/id/notes/note_id"

	payload := strings.NewReader("{\n  \"content\": \"string\"\n}")

	req, _ := http.NewRequest("PUT", 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://app.hindsiteind.com/api/v2/work_orders/id/notes/note_id")

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

request = Net::HTTP::Put.new(url)
request["Authorization"] = 'Bearer <token>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"content\": \"string\"\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.put("https://app.hindsiteind.com/api/v2/work_orders/id/notes/note_id")
  .header("Authorization", "Bearer <token>")
  .header("Content-Type", "application/json")
  .body("{\n  \"content\": \"string\"\n}")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('PUT', 'https://app.hindsiteind.com/api/v2/work_orders/id/notes/note_id', [
  'body' => '{
  "content": "string"
}',
  'headers' => [
    'Authorization' => 'Bearer <token>',
    'Content-Type' => 'application/json',
  ],
]);

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

```csharp
using RestSharp;

var client = new RestClient("https://app.hindsiteind.com/api/v2/work_orders/id/notes/note_id");
var request = new RestRequest(Method.PUT);
request.AddHeader("Authorization", "Bearer <token>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"content\": \"string\"\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = [
  "Authorization": "Bearer <token>",
  "Content-Type": "application/json"
]
let parameters = ["content": "string"] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "https://app.hindsiteind.com/api/v2/work_orders/id/notes/note_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
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()
```