Fleetbase PHP SDK API examples

These 220 examples are generated from the locked official Postman contract. CI executes every fenced snippet against a hermetic PSR-18 transport.

Create $fleetbase once as shown in the README, then use the relevant service call below. Fixture identifiers and payloads are illustrative; replace them with values from your application.

Contacts

Create a Contact

Creates a contact for the current company. Contacts are used as customers, facilitators, personnel, or other addressable people in Fleet-Ops workflows.

POST {{base_url}}/{{namespace}}/contacts

$result = $fleetbase->contacts->createContact(
    [
        'name' => 'John Doe',
        'type' => 'customer',
        'title' => 'Mr',
        'email' => 'john@exampleco.com',
        'phone' => '+1 563-920-4264',
    ]
);

Delete a Contact

Delete a Contact.

DELETE {{base_url}}/{{namespace}}/contacts/:id

$result = $fleetbase->contacts->deleteContact($contactId);

Query Contacts

Returns a paginated list of contacts for the current organization. Use filters such as query, limit, offset, and sort to narrow and order the results.

GET {{base_url}}/{{namespace}}/contacts

$result = $fleetbase->contacts->queryContacts(
    [
        'query' => 'contact_name-fixture',
        'limit' => '25',
        'offset' => '0',
        'sort' => 'created_at',
    ]
);

Retrieve a Contact

Retrieve a Contact.

GET {{base_url}}/{{namespace}}/contacts/:id

$result = $fleetbase->contacts->retrieveContact($contactId);

Update a Contact

Updates a contact's profile, type, primary place, photo, or metadata.

PUT {{base_url}}/{{namespace}}/contacts/:id

$result = $fleetbase->contacts->updateContact(
    $contactId,
    [
        'name' => 'John Doe',
        'title' => 'Mr',
        'email' => 'john@exampleco.com',
        'phone' => '563-920-4264',
        'meta' => [
            'external_ref' => 'john-doe',
        ],
    ]
);

Customers

Create a Customer

Creates a customer account (Contact + linked User) after verifying the code from Request Customer Creation Code. Returns the customer with a Sanctum token — persist this client-side and send it back as the Customer-Token header on authenticated requests.

POST {{base_url}}/{{namespace}}/customers

$result = $fleetbase->customers->createCustomer(
    [
        'identity' => 'customer_identity-fixture',
        'code' => 'verification_code-fixture',
        'name' => 'Jane Customer',
        'password' => 'customer_password-fixture',
        'phone' => 'randomPhoneNumber-fixture',
        'place' => [
            'name' => 'Home',
            'street1' => '123 Main Street',
            'city' => 'Kingston',
            'province' => 'Kingston',
            'postal_code' => '00000',
            'country' => 'JM',
        ],
    ]
);

Create a Customer Order

Creates an Order on behalf of the authenticated customer. Accepts the canonical Fleet-Ops Order create shape — the same fields as POST /v1/orders would accept from an operator. The customer's uuid is automatically attached as orders.customer_uuid; any client-supplied customer field is ignored. status is forced to created (customers cannot self-dispatch). The Order lands in the company resolved from the API credential.

POST {{base_url}}/{{namespace}}/customers/orders

$result = $fleetbase->customers->createCustomerOrder(
    [
        'type' => 'transport',
        'scheduled_at' => '2026-05-25T10:00:00Z',
        'notes' => 'Handle with care.',
        'pickup' => [
            'name' => 'Pickup',
            'street1' => '4169 N State RD 7',
            'city' => 'Lauderdale Lakes',
            'province' => 'FL',
            'postal_code' => '33319',
            'country' => 'US',
        ],
        'dropoff' => [
            'name' => 'Dropoff',
            'city' => 'Kingston',
            'country' => 'JM',
        ],
        'entities' => [
            [
                'name' => 'Wireless Headphones',
                'description' => 'Electronics',
                'weight' => 2.5,
                'weight_unit' => 'lb',
                'declared_value' => 150,
                'currency' => 'USD',
            ],
        ],
    ]
);

Forgot Customer Password

Sends a password-reset verification code to the customer's email or phone. Always returns { status: ok } regardless of whether the identity matches an account (prevents enumeration).

POST {{base_url}}/{{namespace}}/customers/forgot-password

$result = $fleetbase->customers->forgotCustomerPassword(
    [
        'identity' => 'customer_identity-fixture',
    ]
);

List Customer Orders

Lists orders owned by the authenticated customer (scoped to orders.customer_uuid).

GET {{base_url}}/{{namespace}}/customers/orders

$result = $fleetbase->customers->listCustomerOrders();

List Customer Places

Lists the authenticated customer's saved Places (delivery addresses, etc.).

GET {{base_url}}/{{namespace}}/customers/places

$result = $fleetbase->customers->listCustomerPlaces();

Login Customer

Authenticates a customer with email/phone + password. Returns the customer with a Sanctum token to use as Customer-Token.

POST {{base_url}}/{{namespace}}/customers/login

$result = $fleetbase->customers->loginCustomer(
    [
        'identity' => 'customer_identity-fixture',
        'password' => 'customer_password-fixture',
    ]
);

Logout All Customer Sessions

Revokes every Sanctum token issued to the customer's linked user (sign out everywhere).

POST {{base_url}}/{{namespace}}/customers/logout-all

$result = $fleetbase->customers->logoutAllCustomerSessions();

Logout Customer

Revokes the Sanctum token used to make this request. The customer's other active sessions are unaffected — use Logout All Customer Sessions to revoke every token for the linked user.

POST {{base_url}}/{{namespace}}/customers/logout

$result = $fleetbase->customers->logoutCustomer();

Register Customer Device

Registers a push-notification device token against the authenticated customer's linked user.

POST {{base_url}}/{{namespace}}/customers/register-device

$result = $fleetbase->customers->registerCustomerDevice(
    [
        'token' => 'push_token-fixture',
        'platform' => 'ios',
    ]
);

Request Customer Creation Code

Sends an email or SMS verification code to start a customer signup. Required before calling Create a Customer. Optionally include name and phone so the verification email greets the customer by name and the pending user row is pre-seeded with real values.

POST {{base_url}}/{{namespace}}/customers/request-creation-code

$result = $fleetbase->customers->requestCustomerCreationCode(
    [
        'identity' => 'customer_identity-fixture',
        'mode' => 'email',
        'name' => 'customer_name-fixture',
        'phone' => 'customer_phone-fixture',
    ]
);

Request Customer Login SMS

Starts SMS-based passwordless login by sending a verification code to the customer's phone. Falls back to email if SMS delivery fails and an email is on file.

POST {{base_url}}/{{namespace}}/customers/login-with-sms

$result = $fleetbase->customers->requestCustomerLoginSms(
    [
        'phone' => 'customer_phone-fixture',
    ]
);

Reset Customer Password

Verifies the reset code from Forgot Customer Password and sets a new password. All existing tokens for the customer's user are revoked on success.

POST {{base_url}}/{{namespace}}/customers/reset-password

$result = $fleetbase->customers->resetCustomerPassword(
    [
        'identity' => 'customer_identity-fixture',
        'code' => 'verification_code-fixture',
        'password' => 'customer_password-fixture',
    ]
);

Retrieve Authenticated Customer

Returns the profile of the customer identified by the Customer-Token header.

GET {{base_url}}/{{namespace}}/customers/me

$result = $fleetbase->customers->retrieveAuthenticatedCustomer();

Retrieve a Customer Order

Fetches a single order by id, public id, or tracking number. Returns 404 if the order doesn't belong to the authenticated customer.

GET {{base_url}}/{{namespace}}/customers/orders/{{customer_order_id}}

$result = $fleetbase->customers->retrieveCustomerOrder($customerOrderId);

Update Authenticated Customer

Updates the authenticated customer's profile. Changes to name, email, and phone are mirrored onto the linked user so subsequent logins work.

PUT {{base_url}}/{{namespace}}/customers/me

$result = $fleetbase->customers->updateAuthenticatedCustomer(
    [
        'name' => 'customer_name-fixture',
        'phone' => 'customer_phone-fixture',
        'email' => 'customer_email-fixture',
    ]
);

Verify Customer Login Code

Verifies the SMS/email code from Request Customer Login SMS and returns the customer with a Sanctum token. When for is fleetops_create_customer this proxies to Create a Customer.

POST {{base_url}}/{{namespace}}/customers/verify-code

$result = $fleetbase->customers->verifyCustomerLoginCode(
    [
        'identity' => 'customer_identity-fixture',
        'code' => 'verification_code-fixture',
        'for' => 'fleetops_customer_login',
    ]
);

Devices

Attach Device

Attach this device to a vehicle.

POST {{base_url}}/{{namespace}}/devices/{{device_id}}/attach

$result = $fleetbase->devices->attachDevice(
    $deviceId,
    [
        'vehicle' => 'vehicle_id-fixture',
    ]
);

Create a Device

Create a device.

POST {{base_url}}/{{namespace}}/devices

$result = $fleetbase->devices->createDevice(
    [
        'name' => 'OBD Tracker 12',
        'type' => 'obd',
        'device_id' => 'OBD-12',
        'serial_number' => 'SN-10001',
        'status' => 'active',
    ]
);

Delete a Device

Delete a device.

DELETE {{base_url}}/{{namespace}}/devices/{{device_id}}

$result = $fleetbase->devices->deleteDevice($deviceId);

Detach Device

Detach this device from its current resource.

POST {{base_url}}/{{namespace}}/devices/{{device_id}}/detach

$result = $fleetbase->devices->detachDevice($deviceId);

Query Devices

Query devices.

GET {{base_url}}/{{namespace}}/devices

$result = $fleetbase->devices->queryDevices();

Retrieve a Device

Retrieve a device.

GET {{base_url}}/{{namespace}}/devices/{{device_id}}

$result = $fleetbase->devices->retrieveDevice($deviceId);

Update a Device

Update a device.

PUT {{base_url}}/{{namespace}}/devices/{{device_id}}

$result = $fleetbase->devices->updateDevice(
    $deviceId,
    [
        'status' => 'maintenance',
    ]
);

Drivers

Change Driver Password

Changes the password of a driver who is signed in, proving the current one. A password change is an authorisation decision rather than an attribute update, which is why it is not part of PUT /drivers/:id — that endpoint does not accept a password at all. Supplying the wrong current_password is refused and changes nothing. Every other session is revoked when the password changes, and a fresh token is returned in the same response, so the caller keeps working while other devices are signed out.

POST {{base_url}}/{{namespace}}/drivers/:id/change-password

$result = $fleetbase->drivers->changeDriverPassword(
    $driverId,
    [
        'current_password' => 'created_driver_password-fixture',
        'password' => 'driver_new_password-fixture',
        'password_confirmation' => 'driver_new_password-fixture',
        'device_name' => 'navigator',
    ]
);

Create a Driver

Creates a driver profile and linked user account. Provide a unique email and phone number, then optionally assign a vehicle, vendor, current job, location, or photo.

POST {{base_url}}/{{namespace}}/drivers

$result = $fleetbase->drivers->createDriver(
    [
        'name' => 'John Doe',
        'email' => 'randomEmail-fixture',
        'phone' => 'randomPhoneNumber-fixture',
        'password' => 'driver_seed_password-fixture',
    ]
);

Delete a Driver

Use this endpoint to delete a driver.

DELETE {{base_url}}/{{namespace}}/drivers/:id

$result = $fleetbase->drivers->deleteDriver($driverId);

Get Driver Current Organization

Returns the driver current organization.

GET {{base_url}}/{{namespace}}/drivers/:id/current-organization

$result = $fleetbase->drivers->getDriverCurrentOrganization($driverId);

List Driver Manifests

Lists the manifests assigned to a driver, newest first. A manifest is a driver's route: an order-agnostic sequence of stops which may span several orders, or none the driver has seen as an order. Defaults to a recent window rather than the driver's whole history. Use status and on to narrow it further.

GET {{base_url}}/{{namespace}}/drivers/:id/manifests

$result = $fleetbase->drivers->listDriverManifests($driverId);

List Driver Organizations

Lists organizations a driver belongs to.

GET {{base_url}}/{{namespace}}/drivers/:id/organizations

$result = $fleetbase->drivers->listDriverOrganizations($driverId);

Login Driver

Authenticates a driver with email/phone and password.

POST {{base_url}}/{{namespace}}/drivers/login

$result = $fleetbase->drivers->loginDriver(
    [
        'identity' => 'driver_identity-fixture',
        'password' => 'driver_password-fixture',
    ]
);

Query Drivers

Returns drivers for the current company. Use filters such as vendor, search, pagination, or sort parameters to narrow the result set.

GET {{base_url}}/{{namespace}}/drivers

$result = $fleetbase->drivers->queryDrivers(
    [
        'id' => 'driver_id-fixture',
    ]
);

Register Device

Registers a driver device token through the non-id route.

POST {{base_url}}/{{namespace}}/drivers/register-device

$result = $fleetbase->drivers->registerDevice(
    [
        'token' => 'device_token-fixture',
        'platform' => 'ios',
    ]
);

Register Driver Device

Registers a device token for a specific driver.

POST {{base_url}}/{{namespace}}/drivers/:id/register-device

$result = $fleetbase->drivers->registerDriverDevice(
    $driverId,
    [
        'token' => 'device_token-fixture',
        'platform' => 'ios',
    ]
);

Request Driver Login SMS

Starts driver SMS verification login.

POST {{base_url}}/{{namespace}}/drivers/login-with-sms

$result = $fleetbase->drivers->requestDriverLoginSms(
    [
        'phone' => 'driver_phone-fixture',
    ]
);

Request Driver Password Reset

Sends a password reset code to a driver who cannot sign in. The code goes by email or SMS depending on whether identity looks like an email address or a phone number. The response is the same whether or not the identity belongs to a driver. That is deliberate: an endpoint that answered differently for an unknown number would be a way to enumerate an organization's drivers. driver_reset_identity defaults to a reserved address that belongs to nobody, so running the collection documents the endpoint without sending mail to a stranger. Point it at a real driver to exercise delivery.

POST {{base_url}}/{{namespace}}/drivers/forgot-password

$result = $fleetbase->drivers->requestDriverPasswordReset(
    [
        'identity' => 'driver_reset_identity-fixture',
    ]
);

Reset Driver Password

Sets a new password using the code sent by POST /drivers/forgot-password. A wrong code, an expired code and an unknown identity all return the same error, so the endpoint cannot be used to test which of the three happened. Every session is revoked on success. A reset is a recovery from losing control of an account, so nothing that was signed in stays signed in. driver_password_reset_code is a code issued for this flow specifically — a login code will not do, because the endpoint matches on purpose as well as on value. The password is set back to the one already in force so the run stays repeatable and the driver login requests further down still authenticate.

POST {{base_url}}/{{namespace}}/drivers/reset-password

$result = $fleetbase->drivers->resetDriverPassword(
    [
        'identity' => 'driver_identity-fixture',
        'code' => 'driver_password_reset_code-fixture',
        'password' => 'driver_password-fixture',
    ]
);

Retrieve a Driver

This endpoint allows you to retrieve a driver object to view it's details.

GET {{base_url}}/{{namespace}}/drivers/:id

$result = $fleetbase->drivers->retrieveDriver($driverId);

Simulate Driver Route

Simulates driver movement between two resolvable points, or pass order to simulate an order route.

POST {{base_url}}/{{namespace}}/drivers/:id/simulate

$result = $fleetbase->drivers->simulateDriverRoute(
    $driverId,
    [
        'start' => [
            'latitude' => 1.3521,
            'longitude' => 103.8198,
        ],
        'end' => [
            'latitude' => 1.2903,
            'longitude' => 103.8519,
        ],
    ]
);

Switch Driver Organization

Switches the driver session to another organization. The driver must already belong to the target organization, and it must not be the one they are currently in — switching to the current organization is rejected. A driver created through POST /drivers belongs to a single organization, so this example uses one that belongs to more than one.

POST {{base_url}}/{{namespace}}/drivers/:id/switch-organization

$result = $fleetbase->drivers->switchDriverOrganization(
    $driverId,
    [
        'next' => 'secondary_organization_id-fixture',
    ]
);

Toggle Driver Online

Toggles or sets driver online status.

POST {{base_url}}/{{namespace}}/drivers/:id/toggle-online

$result = $fleetbase->drivers->toggleDriverOnline(
    $driverId,
    [
        'online' => true,
    ]
);

Track Driver

PATCH {{base_url}}/{{namespace}}/drivers/:id/track

$result = $fleetbase->drivers->trackDriver(
    $driverId,
    [
        'latitude' => -19.288195,
        'longitude' => 146.795965,
        'speed' => 100,
    ]
);

Update a Driver

Updates a driver's account fields, assignment, status, location, photo, or metadata.

PUT {{base_url}}/{{namespace}}/drivers/:id

$result = $fleetbase->drivers->updateDriver(
    $driverId,
    [
        'name' => 'John Doe',
        'email' => 'randomEmail-fixture',
        'phone' => 'randomPhoneNumber-fixture',
    ]
);

Verify Driver Login Code

Verifies driver login code and returns a driver token.

POST {{base_url}}/{{namespace}}/drivers/verify-code

$result = $fleetbase->drivers->verifyDriverLoginCode(
    [
        'identity' => 'driver_identity-fixture',
        'code' => 'verification_code-fixture',
    ]
);

Entities

Create an Entity

Creates an entity such as a parcel, package, or item. Attach it to a payload and optionally set a destination or waypoint within that payload route.

POST {{base_url}}/{{namespace}}/entities

$result = $fleetbase->entities->createEntity(
    [
        'name' => 'SampleEntity',
        'type' => 'parcel',
        'payload' => 'payload_id-fixture',
        'customer' => 'ACustomer',
        'internal_id' => 'ENTITY001',
        'description' => 'Sample description',
        'meta' => [
            'warehouse_bin' => '1',
            'warehouse_rack' => '3',
            'warehouse_section' => '4',
        ],
        'weight' => 2.5,
        'weight_unit' => 'kg',
        'length' => 10,
        'width' => 5,
        'height' => 8,
        'dimensions_unit' => 'mm',
        'declared_value' => 1500,
        'price' => 1200,
        'sale_price' => 900,
        'sku' => 'SKU123',
        'currency' => 'USD',
    ]
);

Delete a Entity

Delete an Entity.

DELETE {{base_url}}/{{namespace}}/entities/:id

$result = $fleetbase->entities->deleteEntity($entityId);

Query Entities

Returns entities for the current company. Use filters such as type, payload, or destination to narrow the result set.

GET {{base_url}}/{{namespace}}/entities

$result = $fleetbase->entities->queryEntities(
    [
        'limit' => '25',
        'offset' => '0',
        'sort' => 'created_at',
        'type' => 'parcel',
    ]
);

Retrieve an Entity

Retrieve an Entity.

GET {{base_url}}/{{namespace}}/entities/:id

$result = $fleetbase->entities->retrieveEntity($entityId);

Update a Entity

Updates an entity's descriptive fields, payload assignment, destination, dimensions, weight, pricing, or metadata.

PUT {{base_url}}/{{namespace}}/entities/:id

$result = $fleetbase->entities->updateEntity(
    $entityId,
    [
        'internal_id' => 'ENTITY001-1',
        'description' => 'New entity description',
        'destination' => '',
        'sku' => 'SKUABC123',
        'currency' => 'SGD',
    ]
);

Equipment

Create Equipment

Create equipment.

POST {{base_url}}/{{namespace}}/equipment

$result = $fleetbase->equipment->createEquipment(
    [
        'name' => 'Liftgate LG-12',
        'code' => 'LG-12',
        'type' => 'liftgate',
        'status' => 'available',
        'serial_number' => 'LG120045',
        'manufacturer' => 'Maxon',
        'model' => 'BMR',
        'currency' => 'USD',
    ]
);

Delete Equipment

Delete equipment.

DELETE {{base_url}}/{{namespace}}/equipment/{{equipment_id}}

$result = $fleetbase->equipment->deleteEquipment($equipmentId);

Query Equipment

Query equipment.

GET {{base_url}}/{{namespace}}/equipment

$result = $fleetbase->equipment->queryEquipment();

Retrieve Equipment

Retrieve equipment.

GET {{base_url}}/{{namespace}}/equipment/{{equipment_id}}

$result = $fleetbase->equipment->retrieveEquipment($equipmentId);

Update Equipment

Update equipment.

PUT {{base_url}}/{{namespace}}/equipment/{{equipment_id}}

$result = $fleetbase->equipment->updateEquipment(
    $equipmentId,
    [
        'status' => 'maintenance',
    ]
);

Fleets

Create a Fleet

Creates a fleet for grouping drivers and vehicles. Assign a service area when the fleet should be constrained to a specific operating area.

POST {{base_url}}/{{namespace}}/fleets

$result = $fleetbase->fleets->createFleet(
    [
        'name' => 'Haulers',
        'service_area' => 'service_area_id-fixture',
    ]
);

Delete a Fleet

Deletes a fleet.

DELETE {{base_url}}/{{namespace}}/fleets/:id

$result = $fleetbase->fleets->deleteFleet($fleetId);

Query Fleets

Returns a paginated list of fleets for the current organization. Use pagination and sorting parameters to control the result set.

GET {{base_url}}/{{namespace}}/fleets

$result = $fleetbase->fleets->queryFleets(
    [
        'limit' => '25',
        'offset' => '0',
        'sort' => 'created_at',
    ]
);

Retrieve a Fleet

Retrieves a fleet.

GET {{base_url}}/{{namespace}}/fleets/:id

$result = $fleetbase->fleets->retrieveFleet($fleetId);

Update a Fleet

Updates a fleet's name or assigned service area.

PUT {{base_url}}/{{namespace}}/fleets/:id

$result = $fleetbase->fleets->updateFleet(
    $fleetId,
    [
        'name' => 'Haulers',
        'service_area' => 'service_area_id-fixture',
    ]
);

Fuel Reports

Create a Fuel Report

POST {{base_url}}/{{namespace}}/fuel-reports

$result = $fleetbase->fuelReports->createFuelReport(
    [
        'driver' => 'driver_id-fixture',
        'odometer' => 12042,
        'volume' => 42.5,
        'metric_unit' => 'liter',
        'location' => [
            'latitude' => 1.3521,
            'longitude' => 103.8198,
        ],
        'amount' => 120.5,
        'currency' => 'USD',
        'status' => 'submitted',
    ]
);

Delete a Fuel Report

DELETE {{base_url}}/{{namespace}}/fuel-reports/:id

$result = $fleetbase->fuelReports->deleteFuelReport($fuelReportId);

Query Fuel Reports

GET {{base_url}}/{{namespace}}/fuel-reports

$result = $fleetbase->fuelReports->queryFuelReports(
    [
        'limit' => '25',
        'offset' => '0',
        'sort' => 'created_at',
    ]
);

Retrieve a Fuel Report

GET {{base_url}}/{{namespace}}/fuel-reports/:id

$result = $fleetbase->fuelReports->retrieveFuelReport($fuelReportId);

Update a Fuel Report

PUT {{base_url}}/{{namespace}}/fuel-reports/:id

$result = $fleetbase->fuelReports->updateFuelReport(
    $fuelReportId,
    [
        'odometer' => 12050,
        'volume' => 43.1,
        'metric_unit' => 'liter',
        'amount' => 122.75,
        'currency' => 'USD',
        'status' => 'approved',
    ]
);

Fuel Transactions

Create a Fuel Transaction

Create a fuel transaction.

POST {{base_url}}/{{namespace}}/fuel-transactions

$result = $fleetbase->fuelTransactions->createFuelTransaction(
    [
        'provider' => 'petroapp',
        'provider_transaction_id' => 'TX-timestamp-fixture',
        'vehicle' => 'vehicle_id-fixture',
        'station_name' => 'North Depot Fuel',
        'transaction_at' => '2026-05-07T08:30:00Z',
        'volume' => 42.5,
        'metric_unit' => 'liter',
        'amount' => 6500,
        'currency' => 'USD',
    ]
);

Delete a Fuel Transaction

Delete a fuel transaction.

DELETE {{base_url}}/{{namespace}}/fuel-transactions/{{fuel_transaction_id}}

$result = $fleetbase->fuelTransactions->deleteFuelTransaction($fuelTransactionId);

Match Fuel Transaction Order

Match this fuel transaction to an order.

POST {{base_url}}/{{namespace}}/fuel-transactions/{{fuel_transaction_id}}/match-order

$result = $fleetbase->fuelTransactions->matchFuelTransactionOrder(
    $fuelTransactionId,
    [
        'order' => 'order_id-fixture',
    ]
);

Match Fuel Transaction Vehicle

Match this fuel transaction to a vehicle.

POST {{base_url}}/{{namespace}}/fuel-transactions/{{fuel_transaction_id}}/match-vehicle

$result = $fleetbase->fuelTransactions->matchFuelTransactionVehicle(
    $fuelTransactionId,
    [
        'vehicle' => 'vehicle_id-fixture',
    ]
);

Query Fuel Transactions

Query fuel transactions.

GET {{base_url}}/{{namespace}}/fuel-transactions

$result = $fleetbase->fuelTransactions->queryFuelTransactions();

Reprocess Fuel Transaction

Reprocess matching and fuel report generation for this fuel transaction.

POST {{base_url}}/{{namespace}}/fuel-transactions/{{fuel_transaction_id}}/reprocess

$result = $fleetbase->fuelTransactions->reprocessFuelTransaction($fuelTransactionId);

Retrieve a Fuel Transaction

Retrieve a fuel transaction.

GET {{base_url}}/{{namespace}}/fuel-transactions/{{fuel_transaction_id}}

$result = $fleetbase->fuelTransactions->retrieveFuelTransaction($fuelTransactionId);

Review Fuel Transaction

Mark this fuel transaction as reviewed or ignored.

POST {{base_url}}/{{namespace}}/fuel-transactions/{{fuel_transaction_id}}/review

$result = $fleetbase->fuelTransactions->reviewFuelTransaction(
    $fuelTransactionId,
    [
        'status' => 'reviewed',
    ]
);

Update a Fuel Transaction

Update a fuel transaction.

PUT {{base_url}}/{{namespace}}/fuel-transactions/{{fuel_transaction_id}}

$result = $fleetbase->fuelTransactions->updateFuelTransaction(
    $fuelTransactionId,
    [
        'sync_status' => 'reviewed',
    ]
);

Geofences

Get Driver Geofence History

GET {{base_url}}/{{namespace}}/geofences/driver/:driverId/history

$result = $fleetbase->geofences->getDriverGeofenceHistory(
    $driverId,
    [
        'per_page' => '50',
    ]
);

Get Geofence Dwell Report

GET {{base_url}}/{{namespace}}/geofences/dwell-report

$result = $fleetbase->geofences->getGeofenceDwellReport(
    [
        'from' => 'from_datetime-fixture',
        'to' => 'to_datetime-fixture',
    ]
);

Get Geofence Inventory

GET {{base_url}}/{{namespace}}/geofences/inventory

$result = $fleetbase->geofences->getGeofenceInventory();

List Geofence Events

GET {{base_url}}/{{namespace}}/geofences/events

$result = $fleetbase->geofences->listGeofenceEvents(
    [
        'per_page' => '50',
        'event_type' => 'entered',
    ]
);

Issues

Create an Issue

POST {{base_url}}/{{namespace}}/issues

$result = $fleetbase->issues->createIssue(
    [
        'driver' => 'driver_id-fixture',
        'location' => [
            'latitude' => 1.3521,
            'longitude' => 103.8198,
        ],
        'report' => 'Vehicle tire pressure warning',
        'category' => 'vehicle',
        'type' => 'maintenance',
        'priority' => 'medium',
        'status' => 'open',
    ]
);

Delete an Issue

DELETE {{base_url}}/{{namespace}}/issues/:id

$result = $fleetbase->issues->deleteIssue($issueId);

Query Issues

GET {{base_url}}/{{namespace}}/issues

$result = $fleetbase->issues->queryIssues(
    [
        'limit' => '25',
        'offset' => '0',
        'sort' => 'created_at',
    ]
);

Retrieve an Issue

GET {{base_url}}/{{namespace}}/issues/:id

$result = $fleetbase->issues->retrieveIssue($issueId);

Update an Issue

PUT {{base_url}}/{{namespace}}/issues/:id

$result = $fleetbase->issues->updateIssue(
    $issueId,
    [
        'report' => 'Updated issue report',
        'category' => 'vehicle',
        'type' => 'maintenance',
        'priority' => 'high',
        'status' => 'resolved',
    ]
);

Labels

Render Label

Renders a PDF, text, or base64 label for an order, waypoint, or entity id.

GET {{base_url}}/{{namespace}}/labels/:id

$result = $fleetbase->labels->renderLabel(
    $labelId,
    [
        'format' => 'stream',
        'type' => 'order',
    ]
);

Manifests

Optimize a Manifest

Re-sequences the stops a driver has not done yet, nearest first. This is the driver's optimise, not the orchestrator's. The orchestrator allocates orders across a fleet and produces manifests; this reorders the stops of one manifest that is already assigned. It is a nearest-neighbour walk over road distances: from the driver's position to the closest remaining stop, then the closest from there. That is usually a large improvement on an arbitrary order and is not guaranteed optimal. Completed and skipped stops keep their place — a route already driven is not re-planned. A manifest with fewer than three stops still to do is returned unchanged, since there is no ordering to find. Send latitude and longitude to start the walk from where the driver actually is. Without them it starts from the first stop still to do.

POST {{base_url}}/{{namespace}}/manifests/:id/optimize

$result = $fleetbase->manifests->optimizeManifest(
    $manifestId,
    [
        'latitude' => 1.3521,
        'longitude' => 103.8198,
    ]
);

Retrieve a Manifest

Retrieves a manifest with its stops, in the sequence they are to be driven. Each stop carries its place inline — a route of twenty stops is one request, not twenty-one — along with its status, estimated and actual arrival, and the distance and duration from the previous stop.

GET {{base_url}}/{{namespace}}/manifests/:id

$result = $fleetbase->manifests->retrieveManifest($manifestId);

Update a Manifest Stop

Marks a stop on a manifest as arrived, completed or skipped. Status changes run through the manifest's own transitions rather than writing a column, so arrival and completion timestamps are recorded and a manifest completes itself when its last stop does. Any other status is refused and changes nothing.

PATCH {{base_url}}/{{namespace}}/manifest-stops/:id

$result = $fleetbase->manifests->updateManifestStop(
    $manifestId,
    [
        'status' => 'arrived',
    ]
);

Onboard

Get Driver Onboard Settings

Returns driver onboarding settings for an organization.

GET {{base_url}}/{{namespace}}/onboard/driver-onboard-settings/:companyId

$result = $fleetbase->onboard->getDriverOnboardSettings($companyId);

Orchestrator

Commit Orchestrator Plan

Commits a proposed orchestrator plan by creating manifests and applying vehicle and driver assignments to orders. Assignment records must use public resource IDs. This endpoint is engine-agnostic: commit the assignments returned by route-aware VROOM, VROOM capacity-only, native capacity-only, or multi-phase orchestration runs. Do not submit internal UUIDs or database IDs.

POST {{base_url}}/{{namespace}}/orchestrator/commit

$result = $fleetbase->orchestrator->commitOrchestratorPlan(
    [
        'scheduled_date' => '2026-05-16',
        'assignments' => [
            [
                'order_id' => 'order_id-fixture',
                'vehicle_id' => 'vehicle_id-fixture',
                'driver_id' => 'driver_id-fixture',
                'sequence' => 1,
                'arrival' => 1778918400,
                'duration' => 900,
                'distance' => 4200,
            ],
        ],
    ]
);

Run Orchestrator

Runs an orchestration phase and returns a proposed assignment plan without committing changes. Use options.engine to force an engine: greedy and capacity are built in and need no external service, while vroom requires a reachable VROOM instance. Omitting options.engine uses the orchestrator engine configured in admin settings, which defaults to greedy. For normal route-aware VROOM allocation, send options.engine: "vroom" and omit allocation_strategy or set it to route_aware. Vehicles must have usable positions because VROOM will solve against route coordinates. For capacity-only VROOM allocation, send options.engine: "vroom" and options.allocation_strategy: "capacity_only". This mode answers which vehicles can carry the selected orders by weight, volume, pallets, parcels, skills, and task limits without requiring vehicle locations. Use options.vehicle_packing: "minimize_vehicles" to bias VROOM toward filling feasible vehicles before opening another vehicle; use balanced or none to disable that packing bias. For Fleetbase's deterministic built-in capacity allocation, send options.engine: "capacity". This native engine is useful as a fallback and debugging baseline for capacity-only allocation without VROOM. The consumable API accepts and returns public IDs only. Use order_ids, vehicle_ids, driver_ids, prior_assignments.*_id, and response *_id values as public IDs. Do not submit internal UUIDs.

POST {{base_url}}/{{namespace}}/orchestrator/run

$result = $fleetbase->orchestrator->runOrchestrator(
    [
        'mode' => 'assign_vehicles',
        'order_ids' => [
            'order_id-fixture',
        ],
        'vehicle_ids' => [
            'vehicle_id-fixture',
        ],
        'driver_ids' => [],
        'prior_assignments' => [],
        'options' => [
            'engine' => 'greedy',
            'allocation_strategy' => 'route_aware',
            'geometry' => false,
            'respect_capacity' => true,
            'respect_skills' => true,
            'return_to_depot' => false,
        ],
    ]
);

Order Configs

Query Order Configs

Lists OrderConfigs available to the company resolved from the API credential.

GET {{base_url}}/{{namespace}}/order-configs

$result = $fleetbase->orderConfigs->queryOrderConfigs();

Retrieve an Order Config

Fetches a single OrderConfig. The {id} segment accepts any identifier supported by OrderConfig::resolveFromIdentifier — uuid, public_id, namespace, or short key. Use transport to retrieve the system default flow.

GET {{base_url}}/{{namespace}}/order-configs/{{order_config_id}}

$result = $fleetbase->orderConfigs->retrieveOrderConfig($orderConfigId);

Orders

Cancel an Order

Cancels an order without deleting the order resource.

DELETE {{base_url}}/{{namespace}}/orders/:id/cancel

$result = $fleetbase->orders->cancelOrder($orderId);

Capture Photo for Order

Captures proof photos for an order or order subject.

POST {{base_url}}/{{namespace}}/orders/:id/capture-photo/:subjectId

$result = $fleetbase->orders->capturePhotoForOrder(
    $orderId,
    $subjectId,
    [
        'photos' => [
            'proof_photo_base64-fixture',
        ],
        'remarks' => 'Verified by Photo',
        'data' => [],
    ]
);

Capture QR Code for Order

Captures a QR code proof for an order or order subject. The response includes the updated proof data associated with the order.

POST {{base_url}}/{{namespace}}/orders/:id/capture-qr/:subject-id

$result = $fleetbase->orders->captureQrCodeForOrder(
    $orderId,
    $subjectId,
    [
        'code' => 'qr_code-fixture',
        'data' => [],
        'raw_data' => [],
    ]
);

Capture Signature for Order

Captures a signature proof for an order or order subject. Use this when a workflow requires signed proof of delivery or pickup.

POST {{base_url}}/{{namespace}}/orders/:id/capture-signature/:subject-id

$result = $fleetbase->orders->captureSignatureForOrder(
    $orderId,
    $subjectId,
    [
        'signature' => 'proof_signature_base64-fixture',
        'data' => [],
    ]
);

Complete an Order

Completes an order after all waypoints are complete.

POST {{base_url}}/{{namespace}}/orders/:id/complete

$result = $fleetbase->orders->completeOrder($orderId);

Create an Order

Creates a new order for the current company. Provide an existing payload ID, an inline payload, a pickup/dropoff pair, or at least two waypoints; Fleetbase creates or attaches the payload before creating the order. You can assign a driver, vehicle, facilitator, customer, service quote, or schedule at creation time. When dispatch is true, Fleetbase dispatches the order after it is created unless the order belongs to an integrated vendor flow.