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

# Mark Tracking Uploaded

POST https://sandbox-api.shipbob.com/2026-01/shipment:batchUpdateTrackingUpload
Content-Type: application/json-patch+json

Mark tracking information as synced to your external system for multiple shipments. Use this endpoint after syncing tracking data to update the IsTrackingUploaded flag, preventing these shipments from appearing in future GET /order queries with IsTrackingUploaded=false.

<Tip>Use this endpoint if you're filtering orders by is_tracking_uploaded. This allows integrations to acknowledge that shipments have been successfully synced to their system.</Tip>

Reference: https://developer-stage.shipbob.dev/api/orders/mark-tracking-uploaded

## OpenAPI Specification

```yaml
openapi: 3.1.0
info:
  title: api-2026-01
  version: 1.0.0
paths:
  /2026-01/shipment:batchUpdateTrackingUpload:
    post:
      operationId: mark-tracking-uploaded
      summary: Mark Tracking Uploaded
      description: >-
        Mark tracking information as synced to your external system for multiple
        shipments. Use this endpoint after syncing tracking data to update the
        IsTrackingUploaded flag, preventing these shipments from appearing in
        future GET /order queries with IsTrackingUploaded=false.


        <Tip>Use this endpoint if you're filtering orders by
        is_tracking_uploaded. This allows integrations to acknowledge that
        shipments have been successfully synced to their system.</Tip>
      tags:
        - subpackage_orders
      parameters:
        - name: Authorization
          in: header
          description: Authentication using Personal Access Token (PAT) token
          required: true
          schema:
            type: string
      responses:
        '200':
          description: Success
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Orders.BulkUpdateResponseModel'
        '400':
          description: Bad Request
          content:
            application/json:
              schema:
                $ref: >-
                  #/components/schemas/Orders.Post.Api.Shipment.BulkUpdateTrackingUpload.Bad.Request.String
        '401':
          description: No access right at this time
          content:
            application/json:
              schema:
                description: Any type
        '403':
          description: No access
          content:
            application/json:
              schema:
                description: Any type
        '404':
          description: Not Found
          content:
            application/json:
              schema:
                description: Any type
      requestBody:
        description: ''
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/Orders.BulkUpdateTrackingUploadModel'
servers:
  - url: https://sandbox-api.shipbob.com
    description: https://sandbox-api.shipbob.com
components:
  schemas:
    Orders.BulkUpdateTrackingUploadModel:
      type: object
      properties:
        is_tracking_uploaded:
          type: boolean
          description: "Indicates whether the Shipment was marked with tracking information\r\nuploaded to a third-party system where the order originated.\r\nApplies to all shipments in shipment_ids"
        shipment_ids:
          type: array
          items:
            type: integer
          description: Shipment IDs to apply the tracking upload status to
      description: Model for updating tracking upload status for multiple shipments
      title: Orders.BulkUpdateTrackingUploadModel
    Orders.BulkUpdateResponseError:
      type: object
      properties:
        code:
          type: string
        message:
          type: string
      title: Orders.BulkUpdateResponseError
    Orders.BulkUpdateResponseResult:
      type: object
      properties:
        error:
          $ref: '#/components/schemas/Orders.BulkUpdateResponseError'
        isSuccess:
          type: boolean
        shipmentId:
          type: integer
          format: int64
      title: Orders.BulkUpdateResponseResult
    Orders.BulkUpdateResponseSummary:
      type: object
      properties:
        failed:
          type: integer
        successful:
          type: integer
        total:
          type: integer
      title: Orders.BulkUpdateResponseSummary
    Orders.BulkUpdateResponseModel:
      type: object
      properties:
        results:
          type: array
          items:
            $ref: '#/components/schemas/Orders.BulkUpdateResponseResult'
        summary:
          $ref: '#/components/schemas/Orders.BulkUpdateResponseSummary'
      title: Orders.BulkUpdateResponseModel
    Orders.Post.Api.Shipment.BulkUpdateTrackingUpload.Bad.Request.String:
      type: string
      title: Orders.Post.Api.Shipment.BulkUpdateTrackingUpload.Bad.Request.String
  securitySchemes:
    PAT:
      type: http
      scheme: bearer
      description: Authentication using Personal Access Token (PAT) token
    OAuth2:
      type: http
      scheme: bearer
      description: OAuth2 authentication using JWT tokens

```

## Examples



**Request**

```json
{
  "is_tracking_uploaded": true,
  "shipment_ids": [
    100810005
  ]
}
```

**Response**

```json
{
  "results": [
    {
      "error": {
        "code": "string",
        "message": "string"
      },
      "isSuccess": true,
      "shipmentId": 100810005
    }
  ],
  "summary": {
    "failed": 0,
    "successful": 1,
    "total": 1
  }
}
```

**SDK Code**

```python default
import requests

url = "https://sandbox-api.shipbob.com/2026-01/shipment:batchUpdateTrackingUpload"

payload = "{\n  \"is_tracking_uploaded\": true,\n  \"shipment_ids\": [\n    100810005\n  ]\n}"
headers = {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json-patch+json"
}

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

print(response.json())
```

```javascript default
const url = 'https://sandbox-api.shipbob.com/2026-01/shipment:batchUpdateTrackingUpload';
const options = {
  method: 'POST',
  headers: {Authorization: 'Bearer <token>', 'Content-Type': 'application/json-patch+json'},
  body: '{\n  "is_tracking_uploaded": true,\n  "shipment_ids": [\n    100810005\n  ]\n}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go default
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://sandbox-api.shipbob.com/2026-01/shipment:batchUpdateTrackingUpload"

	payload := strings.NewReader("{\n  \"is_tracking_uploaded\": true,\n  \"shipment_ids\": [\n    100810005\n  ]\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("Authorization", "Bearer <token>")
	req.Header.Add("Content-Type", "application/json-patch+json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby default
require 'uri'
require 'net/http'

url = URI("https://sandbox-api.shipbob.com/2026-01/shipment:batchUpdateTrackingUpload")

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

request = Net::HTTP::Post.new(url)
request["Authorization"] = 'Bearer <token>'
request["Content-Type"] = 'application/json-patch+json'
request.body = "{\n  \"is_tracking_uploaded\": true,\n  \"shipment_ids\": [\n    100810005\n  ]\n}"

response = http.request(request)
puts response.read_body
```

```java default
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://sandbox-api.shipbob.com/2026-01/shipment:batchUpdateTrackingUpload")
  .header("Authorization", "Bearer <token>")
  .header("Content-Type", "application/json-patch+json")
  .body("{\n  \"is_tracking_uploaded\": true,\n  \"shipment_ids\": [\n    100810005\n  ]\n}")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://sandbox-api.shipbob.com/2026-01/shipment:batchUpdateTrackingUpload', [
  'body' => '{
  "is_tracking_uploaded": true,
  "shipment_ids": [
    100810005
  ]
}',
  'headers' => [
    'Authorization' => 'Bearer <token>',
    'Content-Type' => 'application/json-patch+json',
  ],
]);

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

```csharp default
using RestSharp;

var client = new RestClient("https://sandbox-api.shipbob.com/2026-01/shipment:batchUpdateTrackingUpload");
var request = new RestRequest(Method.POST);
request.AddHeader("Authorization", "Bearer <token>");
request.AddHeader("Content-Type", "application/json-patch+json");
request.AddParameter("application/json-patch+json", "{\n  \"is_tracking_uploaded\": true,\n  \"shipment_ids\": [\n    100810005\n  ]\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift default
import Foundation

let headers = [
  "Authorization": "Bearer <token>",
  "Content-Type": "application/json-patch+json"
]

let postData = NSData(data: "{
  "is_tracking_uploaded": true,
  "shipment_ids": [
    100810005
  ]
}".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "https://sandbox-api.shipbob.com/2026-01/shipment:batchUpdateTrackingUpload")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
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()
```