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

# Get Delivery Options

GET https://api.papertracc.com/v1/store/cart/delivery

Lists the delivery options and pickup points for the cart and the shopper's address, each with its fee in the cart's currency and the promised date. Options follow the merchant's cutoff times, closed days, order value and weight rules, so ask again when the cart or address changes. Pickup points come back without an address.

**Keys:** public key or secret key.

Reference: https://api-docs.papertracc.com/storefront/checkout/get-delivery-options

## Authentication

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

## Servers

- `https://api.papertracc.com/v1` (Production, default)
- `https://api.papertracc.com/rc-1` (Release Candidate 1)

## Request

### Query parameters

- `country_code` (string, optional) — ISO 3166-1 alpha-2 code. Defaults to the cart's country.
- `state` (string, optional) — Shopper's state, for example `Lagos`.
- `area` (string, optional) — Shopper's area, for example `Lekki`.

### Headers

- `cart-token` (string, required) — The `token` returned when the cart was created. Treat it as a secret: never put it in a URL or a log.

## Response

### 200

Successfully fetched delivery options

- `status` (boolean, required) — Always `true` on success.
- `message` (string, required) — Human-readable outcome.
- `data` (DeliveryOptions, required)

## Errors

### 400 Bad Request Error

The `channel` header is missing, the body is not valid JSON, or a field failed validation.

- `status` (boolean, required) — Always `false` on a failed request.
- `message` (string, required) — What went wrong, written for the shopper or the developer.
- `error_code` (string, optional) — Present on `402` responses.

### 401 Unauthorized Error

The API key is missing or invalid, the key owner is no longer an active member of the organisation, or the key owner is not a member of the workspace in the `identity` header.

- `status` (boolean, required) — Always `false` on a failed request.
- `message` (string, required) — What went wrong, written for the shopper or the developer.
- `error_code` (string, optional) — Present on `402` responses.

### 402 Payment Required Error

The workspace's subscription plan does not include the Open API.

- `status` (boolean, required) — Always `false` on a failed request.
- `message` (string, required) — What went wrong, written for the shopper or the developer.
- `error_code` (string, optional) — Present on `402` responses.

### 404 Not Found Error

The cart token is missing, unknown or expired, the cart has been checked out, or the line or variant named does not exist.

- `status` (boolean, required) — Always `false` on a failed request.
- `message` (string, required) — What went wrong, written for the shopper or the developer.
- `error_code` (string, optional) — Present on `402` responses.

## Types

### DeliveryOptions

- `required` (boolean, required) — `true` when the store has set up delivery or pickup for the channel and the cart has items to ship. Checkout Cart then requires a `delivery` choice.
- `delivery` (list of DeliveryOffer, required) — Delivery options for the address. Empty until `state` or `area` is given.
- `pickup` (list of DeliveryOffer, required)

### DeliveryOffer

- `kind` (enum, required)
  - Allowed values: `DELIVERY`, `PICKUP`
- `option_id` (string, required, nullable) — Set for delivery offers.
- `pickup_point_id` (string, required, nullable) — Set for pickup offers.
- `location_id` (string, required, nullable)
- `name` (string, required) — The merchant's name for the option, or the store's name for pickup.
- `method` (enum, required)
  - Allowed values: `MERCHANT_RUN`, `PRIME_DISPATCH`, `SAVER_DISPATCH`
- `fee_type` (enum, required) — `LATER` means the merchant sets the fee after the order; `fee` is `0.00` until then.
  - Allowed values: `FLAT`, `LIVE`, `FREE`, `LATER`
- `fee` (string, required) — Fee in the cart's currency.
- `free_applied` (boolean, required) — `true` when the fee is waived because the order is over the option's free-delivery amount.
- `arrives_from` (date, required, nullable)
- `arrives_by` (date, required, nullable) — The promised date. Same as `arrives_from` unless the option gives a range.
- `ready_at` (datetime, required, nullable) — When a pickup order is ready to collect.
- `schedule` (DeliverySchedule, required, nullable) — Present when the shopper picks the delivery day.
- `address` (string, optional) — Pickup point address.
- `instructions` (string, optional) — Pickup instructions from the merchant.

### DeliverySchedule

Present when the shopper picks the delivery day.

- `dates` (list of date, required)
- `windows` (list of DeliveryWindow, required) — Empty when any time that day is fine.

### DeliveryWindow

- `from` (string, required)
- `to` (string, required)

## Examples

**Response**

```json
{
  "status": true,
  "message": "Successfully fetched delivery options",
  "data": {
    "required": true,
    "delivery": [
      {
        "kind": "DELIVERY",
        "option_id": "string",
        "pickup_point_id": "string",
        "location_id": "string",
        "name": "Same day",
        "method": "MERCHANT_RUN",
        "fee_type": "FLAT",
        "fee": "6000.00",
        "free_applied": true,
        "arrives_from": "2023-01-15",
        "arrives_by": "2023-01-15",
        "ready_at": "2024-01-15T09:30:00Z",
        "schedule": {
          "dates": [
            "2023-01-15"
          ],
          "windows": [
            {
              "from": "09:00",
              "to": "13:00"
            }
          ]
        },
        "address": "string",
        "instructions": "string"
      }
    ],
    "pickup": [
      {
        "kind": "DELIVERY",
        "option_id": "string",
        "pickup_point_id": "string",
        "location_id": "string",
        "name": "Same day",
        "method": "MERCHANT_RUN",
        "fee_type": "FLAT",
        "fee": "6000.00",
        "free_applied": true,
        "arrives_from": "2023-01-15",
        "arrives_by": "2023-01-15",
        "ready_at": "2024-01-15T09:30:00Z",
        "schedule": {
          "dates": [
            "2023-01-15"
          ],
          "windows": [
            {
              "from": "09:00",
              "to": "13:00"
            }
          ]
        },
        "address": "string",
        "instructions": "string"
      }
    ]
  }
}
```

**SDK Code**

```python
import requests

url = "https://api.papertracc.com/v1/store/cart/delivery"

headers = {
    "cart-token": "cart-token",
    "channel": "channel",
    "Authorization": "Bearer <apiKey>"
}

response = requests.get(url, headers=headers)

print(response.json())
```

```javascript
const url = 'https://api.papertracc.com/v1/store/cart/delivery';
const options = {
  method: 'GET',
  headers: {
    'cart-token': 'cart-token',
    channel: 'channel',
    Authorization: 'Bearer <apiKey>'
  }
};

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://api.papertracc.com/v1/store/cart/delivery"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("cart-token", "cart-token")
	req.Header.Add("channel", "channel")
	req.Header.Add("Authorization", "Bearer <apiKey>")

	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.papertracc.com/v1/store/cart/delivery")

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

request = Net::HTTP::Get.new(url)
request["cart-token"] = 'cart-token'
request["channel"] = 'channel'
request["Authorization"] = 'Bearer <apiKey>'

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.get("https://api.papertracc.com/v1/store/cart/delivery")
  .header("cart-token", "cart-token")
  .header("channel", "channel")
  .header("Authorization", "Bearer <apiKey>")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.papertracc.com/v1/store/cart/delivery', [
  'headers' => [
    'Authorization' => 'Bearer <apiKey>',
    'cart-token' => 'cart-token',
    'channel' => 'channel',
  ],
]);

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

```csharp
using RestSharp;

var client = new RestClient("https://api.papertracc.com/v1/store/cart/delivery");
var request = new RestRequest(Method.GET);
request.AddHeader("cart-token", "cart-token");
request.AddHeader("channel", "channel");
request.AddHeader("Authorization", "Bearer <apiKey>");
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = [
  "cart-token": "cart-token",
  "channel": "channel",
  "Authorization": "Bearer <apiKey>"
]

let request = NSMutableURLRequest(url: NSURL(string: "https://api.papertracc.com/v1/store/cart/delivery")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
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()
```