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

# Update Fleet

PATCH https://api.catenatelematics.com/v2/orgs/fleets/{fleet_id}
Content-Type: application/json

Update an existing fleet information.

Reference: https://catena.ferndocs.com/api-reference/orgs/fleets/update-fleet

## Authentication

- `Authorization` header (bearer token, required) — Bearer authentication of the form `Bearer <token>`, where token is your auth token.

## Request

### Path parameters

- `fleet_id` (string, required)

### Body (application/json)

This endpoint expects a FleetUpdate.

- `name` (string, optional, nullable) — Primary fleet name
- `description` (string, optional, nullable) — Fleet description or notes
- `display_name` (string, optional, nullable) — Public-facing name
- `legal_name` (string, optional, nullable) — Official registered business name
- `dba_name` (string, optional, nullable) — "Doing Business As" name if different from legal name
- `regulatory_id` (string, optional, nullable) — Regulatory identifier (e.g., DOT number, EASA ID)
- `regulatory_id_type` (string, optional, nullable) — Type of regulatory ID (e.g., DOT, EASA, MC)
- `regulatory_id_date` (date, optional, nullable) — Date when regulatory ID was issued
- `regulatory_id_status` (string, optional, nullable) — Current status of the regulatory ID
- `registered_email` (string, optional, nullable) — Official contact email
- `registered_phone` (string, optional, nullable) — Official contact phone number
- `registered_fax` (string, optional, nullable) — Fax number if applicable
- `address` (string, optional, nullable) — Street address
- `city` (string, optional, nullable) — City
- `province` (string, optional, nullable) — State/Province
- `postal_code` (string, optional, nullable) — ZIP/Postal code
- `country_code` (string, optional, nullable) — ISO-3 country code (e.g., USA, CAN, GBR)
- `fleet_ref` (string, optional, nullable) — A reference for the fleet. Used to store an external identifier for the fleet in your system.

## Response

### 200

Successful Response

- `name` (string, required)
- `fleet_ref` (string, required) — An optional reference for the fleet. Used to store an external identifier for the fleet in your system.
- `id` (string, required) — Unique Catena fleet identifier
- `created_at` (datetime, required) — When the fleet was created
- `updated_at` (datetime, required) — Last modification timestamp
- `description` (string, optional, nullable) — A description of the fleet
- `display_name` (string, optional, nullable)
- `legal_name` (string, optional, nullable)
- `dba_name` (string, optional, nullable)
- `websites` (list of string, optional, nullable) — List of websites associated with the fleet. The website is used to map users to an organization based on their email domain and to authenticate them accordingly in the scope of the organization.
- `invitation_id` (string, optional, nullable) — ID of the invitation that was used to onboard the fleet
- `regulatory_id` (string, optional, nullable) — Primary identifier from a regulatory body for a fleet (like DOT Number).
- `regulatory_id_type` (string, optional, nullable) — Type of the regulatory ID like DOT, EASA, etc.
- `regulatory_id_date` (date, optional, nullable) — Date when the regulatory ID was issued.
- `regulatory_id_status` (string, optional, nullable) — Status of the regulatory ID.
- `registered_email` (string, optional, nullable) — Email address that is registered for the fleet.
- `registered_phone` (string, optional, nullable) — Phone number that is registered for the fleet.
- `registered_fax` (string, optional, nullable) — Fax number that is registered for the fleet.
- `address` (string, optional, nullable) — Physical address that is registered for the fleet.
- `city` (string, optional, nullable) — City that is registered for the fleet.
- `province` (string, optional, nullable) — Province that is registered for the fleet.
- `postal_code` (string, optional, nullable) — Postal code that is registered for the fleet.
- `country_code` (string, optional, nullable) — ISO-3 Country code that is registered for the fleet.

## Errors

### 400 Bad Request Error

Bad Request

- `code` (integer, optional, default: 400)
- `message` (string, optional, default: Bad Request)
- `detail` (string, optional, nullable)

### 401 Unauthorized Error

Unauthorized

- `code` (integer, optional, default: 401)
- `message` (string, optional, default: Unauthorized)
- `detail` (string, optional, nullable)

### 403 Forbidden Error

Forbidden

- `code` (integer, optional, default: 403)
- `message` (string, optional, default: Forbidden)
- `detail` (string, optional, nullable)

### 404 Not Found Error

Not Found

- `code` (integer, optional, default: 404)
- `message` (string, optional, default: Not Found)
- `detail` (string, optional, nullable)

### 405 Method Not Allowed Error

Method Not Allowed

- `code` (integer, optional, default: 405)
- `message` (string, optional, default: Method Not Allowed)
- `detail` (string, optional, nullable)

### 409 Conflict Error

Conflict

- `code` (integer, optional, default: 409)
- `message` (string, optional, default: Conflict)
- `detail` (string, optional, nullable)

### 422 Unprocessable Entity Error

Unprocessable Entity

- `code` (integer, optional, default: 422)
- `message` (string, optional, default: Invalid Request Body)
- `detail` (list of ValidationErrorDetail, optional, nullable)

### 429 Too Many Requests Error

Too Many Requests

- `code` (integer, optional, default: 429)
- `message` (string, optional, default: Too Many Requests)
- `detail` (RetryAfterDetail, optional, nullable)

### 500 Internal Server Error

Internal Server Error

- `message` (string, optional, default: Internal Server Error)

## Types

### ValidationErrorDetail

- `path` (string, required)
- `input` (string, required)
- `message` (string, required)
- `error_type` (string, required)

### RetryAfterDetail

- `retry_after_seconds` (integer, required)
- `message` (string, required)

## Examples

**Request**

```json
{}
```

**Response**

```json
{
  "name": "Swift Transport LLC",
  "fleet_ref": "external-system-12345",
  "id": "98765432-10fe-dcba-9876-543210fedcba",
  "created_at": "2025-12-10T08:15:00Z",
  "updated_at": "2025-12-11T14:30:00Z",
  "description": "Regional freight carrier specializing in temperature-controlled transport",
  "display_name": "Swift Transport",
  "legal_name": "Swift Transport LLC",
  "dba_name": "Swift Logistics",
  "websites": [
    "https://swifttransport.com",
    "https://swiftlogistics.com"
  ],
  "regulatory_id": "1234567",
  "regulatory_id_type": "DOT",
  "regulatory_id_date": "2020-03-15",
  "regulatory_id_status": "ACTIVE",
  "registered_email": "operations@swifttransport.com",
  "registered_phone": "+14155551234",
  "registered_fax": "+14155551235",
  "address": "1234 Industrial Pkwy",
  "city": "San Francisco",
  "province": "California",
  "postal_code": "94107",
  "country_code": "USA"
}
```

**SDK Code**

```python
import requests

url = "https://api.catenatelematics.com/v2/orgs/fleets/fleet_id"

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

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

print(response.json())
```

```javascript
const url = 'https://api.catenatelematics.com/v2/orgs/fleets/fleet_id';
const options = {
  method: 'PATCH',
  headers: {Authorization: 'Bearer <token>', '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://api.catenatelematics.com/v2/orgs/fleets/fleet_id"

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

	req, _ := http.NewRequest("PATCH", 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://api.catenatelematics.com/v2/orgs/fleets/fleet_id")

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

request = Net::HTTP::Patch.new(url)
request["Authorization"] = 'Bearer <token>'
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.patch("https://api.catenatelematics.com/v2/orgs/fleets/fleet_id")
  .header("Authorization", "Bearer <token>")
  .header("Content-Type", "application/json")
  .body("{}")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('PATCH', 'https://api.catenatelematics.com/v2/orgs/fleets/fleet_id', [
  'body' => '{}',
  'headers' => [
    'Authorization' => 'Bearer <token>',
    'Content-Type' => 'application/json',
  ],
]);

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

```csharp
using RestSharp;

var client = new RestClient("https://api.catenatelematics.com/v2/orgs/fleets/fleet_id");
var request = new RestRequest(Method.PATCH);
request.AddHeader("Authorization", "Bearer <token>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "https://api.catenatelematics.com/v2/orgs/fleets/fleet_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"
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()
```