API REFERENCE

Order API

This API features all functionality around orders.

order.api.myparcel.nlv114 endpointsSynced from the live OpenAPI spec

Endpoints

Auto-generated from order.api.myparcel.nl/openapi.yaml. Click an endpoint to see its parameters and code samples.

ADD NOTE
POST/add-noteAdd a note to an order.

Add an order note. Only possible if the order has status=OPEN and the maximum number of 100 notes is not reached.

Responses
StatusDescription
200The request is successfully accepted.
400Invalid request syntax
RequestPOST /add-note
curl -X POST 'https://order.api.myparcel.nl/add-note' \
  -H 'Authorization: bearer <token>' \
  -H 'User-Agent: my-integration/1.0' \
  -H 'Content-Type: application/json' \
  -d '[
  {
    "id": "00000000-0000-0000-0000-000000000000",
    "text": "string"
  }
]'
<?php
$ch = curl_init("https://order.api.myparcel.nl/add-note");
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST  => 'POST',
    CURLOPT_POSTFIELDS     => json_encode([{"id": "00000000-0000-0000-0000-000000000000", "text": "string"}]),
    CURLOPT_HTTPHEADER     => [
        'Authorization: bearer <token>',
        'User-Agent: my-integration/1.0',
        'Content-Type: application/json',
    ],
]);

$response = json_decode(curl_exec($ch), true);
const response = await fetch("https://order.api.myparcel.nl/add-note", {
  method: 'POST',
  headers: {
    Authorization: 'bearer <token>',
    'User-Agent': 'my-integration/1.0',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify([
    {
      "id": "00000000-0000-0000-0000-000000000000",
      "text": "string"
    }
  ]),
});

const data = await response.json();
import requests

headers = {"Authorization": "bearer <token>", "User-Agent": "my-integration/1.0"}

payload = [
    {
        "id": "00000000-0000-0000-0000-000000000000",
        "text": "string"
    }
]

response = requests.post("https://order.api.myparcel.nl/add-note", json=payload, headers=headers)

data = response.json()
require 'net/http'
require 'json'
require 'uri'

uri = URI('https://order.api.myparcel.nl/add-note')
req = Net::HTTP::Post.new(uri)
req['Authorization'] = 'bearer <token>'
req['User-Agent'] = 'my-integration/1.0'
req['Content-Type'] = 'application/json'
req.body = "[{\"id\": \"00000000-0000-0000-0000-000000000000\", \"text\": \"string\"}]"

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
data = JSON.parse(res.body)
package main

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

func main() {
	payload := []byte(`[{"id": "00000000-0000-0000-0000-000000000000", "text": "string"}]`)
	req, _ := http.NewRequest("POST", "https://order.api.myparcel.nl/add-note", bytes.NewBuffer(payload))
	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("Authorization", "bearer <token>")
	req.Header.Set("User-Agent", "my-integration/1.0")

	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)
	fmt.Println(string(body))
}
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Example {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest req = HttpRequest.newBuilder()
            .uri(URI.create("https://order.api.myparcel.nl/add-note"))
            .header("Authorization", "bearer <token>")
            .header("User-Agent", "my-integration/1.0")
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString("[{\"id\": \"00000000-0000-0000-0000-000000000000\", \"text\": \"string\"}]"))
            .build();

        HttpResponse<String> res = client.send(req, HttpResponse.BodyHandlers.ofString());
        System.out.println(res.body());
    }
}
using System.Net.Http;
using System.Text;

var client = new HttpClient();
var req = new HttpRequestMessage(HttpMethod.Post, "https://order.api.myparcel.nl/add-note");
req.Headers.Add("Authorization", "bearer <token>");
req.Headers.Add("User-Agent", "my-integration/1.0");
req.Content = new StringContent(@"[{""id"": ""00000000-0000-0000-0000-000000000000"", ""text"": ""string""}]", Encoding.UTF8, "application/json");

var response = await client.SendAsync(req);
var data = await response.Content.ReadAsStringAsync();
Response200
[]
ASSIGN TO USER
POST/assign-to-userAssign orders to an user. Only possible if the order has `status=OPEN`.

Assign orders to an user. Only possible if the order has status=OPEN.

Responses
StatusDescription
200The request is successfully accepted.
400Invalid request syntax
RequestPOST /assign-to-user
curl -X POST 'https://order.api.myparcel.nl/assign-to-user' \
  -H 'Authorization: bearer <token>' \
  -H 'User-Agent: my-integration/1.0' \
  -H 'Content-Type: application/json' \
  -d '[
  {
    "id": "00000000-0000-0000-0000-000000000000",
    "userId": "string"
  }
]'
<?php
$ch = curl_init("https://order.api.myparcel.nl/assign-to-user");
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST  => 'POST',
    CURLOPT_POSTFIELDS     => json_encode([{"id": "00000000-0000-0000-0000-000000000000", "userId": "string"}]),
    CURLOPT_HTTPHEADER     => [
        'Authorization: bearer <token>',
        'User-Agent: my-integration/1.0',
        'Content-Type: application/json',
    ],
]);

$response = json_decode(curl_exec($ch), true);
const response = await fetch("https://order.api.myparcel.nl/assign-to-user", {
  method: 'POST',
  headers: {
    Authorization: 'bearer <token>',
    'User-Agent': 'my-integration/1.0',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify([
    {
      "id": "00000000-0000-0000-0000-000000000000",
      "userId": "string"
    }
  ]),
});

const data = await response.json();
import requests

headers = {"Authorization": "bearer <token>", "User-Agent": "my-integration/1.0"}

payload = [
    {
        "id": "00000000-0000-0000-0000-000000000000",
        "userId": "string"
    }
]

response = requests.post("https://order.api.myparcel.nl/assign-to-user", json=payload, headers=headers)

data = response.json()
require 'net/http'
require 'json'
require 'uri'

uri = URI('https://order.api.myparcel.nl/assign-to-user')
req = Net::HTTP::Post.new(uri)
req['Authorization'] = 'bearer <token>'
req['User-Agent'] = 'my-integration/1.0'
req['Content-Type'] = 'application/json'
req.body = "[{\"id\": \"00000000-0000-0000-0000-000000000000\", \"userId\": \"string\"}]"

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
data = JSON.parse(res.body)
package main

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

func main() {
	payload := []byte(`[{"id": "00000000-0000-0000-0000-000000000000", "userId": "string"}]`)
	req, _ := http.NewRequest("POST", "https://order.api.myparcel.nl/assign-to-user", bytes.NewBuffer(payload))
	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("Authorization", "bearer <token>")
	req.Header.Set("User-Agent", "my-integration/1.0")

	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)
	fmt.Println(string(body))
}
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Example {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest req = HttpRequest.newBuilder()
            .uri(URI.create("https://order.api.myparcel.nl/assign-to-user"))
            .header("Authorization", "bearer <token>")
            .header("User-Agent", "my-integration/1.0")
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString("[{\"id\": \"00000000-0000-0000-0000-000000000000\", \"userId\": \"string\"}]"))
            .build();

        HttpResponse<String> res = client.send(req, HttpResponse.BodyHandlers.ofString());
        System.out.println(res.body());
    }
}
using System.Net.Http;
using System.Text;

var client = new HttpClient();
var req = new HttpRequestMessage(HttpMethod.Post, "https://order.api.myparcel.nl/assign-to-user");
req.Headers.Add("Authorization", "bearer <token>");
req.Headers.Add("User-Agent", "my-integration/1.0");
req.Content = new StringContent(@"[{""id"": ""00000000-0000-0000-0000-000000000000"", ""userId"": ""string""}]", Encoding.UTF8, "application/json");

var response = await client.SendAsync(req);
var data = await response.Content.ReadAsStringAsync();
Response200
[]
CANCEL
POST/cancelCancel orders.

Cancel orders. Only possible if the order has status=OPEN.

Responses
StatusDescription
200The request is successfully accepted.
400Invalid request syntax
RequestPOST /cancel
curl -X POST 'https://order.api.myparcel.nl/cancel' \
  -H 'Authorization: bearer <token>' \
  -H 'User-Agent: my-integration/1.0' \
  -H 'Content-Type: application/json' \
  -d '[
  {
    "id": "00000000-0000-0000-0000-000000000000"
  }
]'
<?php
$ch = curl_init("https://order.api.myparcel.nl/cancel");
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST  => 'POST',
    CURLOPT_POSTFIELDS     => json_encode([{"id": "00000000-0000-0000-0000-000000000000"}]),
    CURLOPT_HTTPHEADER     => [
        'Authorization: bearer <token>',
        'User-Agent: my-integration/1.0',
        'Content-Type: application/json',
    ],
]);

$response = json_decode(curl_exec($ch), true);
const response = await fetch("https://order.api.myparcel.nl/cancel", {
  method: 'POST',
  headers: {
    Authorization: 'bearer <token>',
    'User-Agent': 'my-integration/1.0',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify([
    {
      "id": "00000000-0000-0000-0000-000000000000"
    }
  ]),
});

const data = await response.json();
import requests

headers = {"Authorization": "bearer <token>", "User-Agent": "my-integration/1.0"}

payload = [
    {
        "id": "00000000-0000-0000-0000-000000000000"
    }
]

response = requests.post("https://order.api.myparcel.nl/cancel", json=payload, headers=headers)

data = response.json()
require 'net/http'
require 'json'
require 'uri'

uri = URI('https://order.api.myparcel.nl/cancel')
req = Net::HTTP::Post.new(uri)
req['Authorization'] = 'bearer <token>'
req['User-Agent'] = 'my-integration/1.0'
req['Content-Type'] = 'application/json'
req.body = "[{\"id\": \"00000000-0000-0000-0000-000000000000\"}]"

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
data = JSON.parse(res.body)
package main

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

func main() {
	payload := []byte(`[{"id": "00000000-0000-0000-0000-000000000000"}]`)
	req, _ := http.NewRequest("POST", "https://order.api.myparcel.nl/cancel", bytes.NewBuffer(payload))
	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("Authorization", "bearer <token>")
	req.Header.Set("User-Agent", "my-integration/1.0")

	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)
	fmt.Println(string(body))
}
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Example {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest req = HttpRequest.newBuilder()
            .uri(URI.create("https://order.api.myparcel.nl/cancel"))
            .header("Authorization", "bearer <token>")
            .header("User-Agent", "my-integration/1.0")
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString("[{\"id\": \"00000000-0000-0000-0000-000000000000\"}]"))
            .build();

        HttpResponse<String> res = client.send(req, HttpResponse.BodyHandlers.ofString());
        System.out.println(res.body());
    }
}
using System.Net.Http;
using System.Text;

var client = new HttpClient();
var req = new HttpRequestMessage(HttpMethod.Post, "https://order.api.myparcel.nl/cancel");
req.Headers.Add("Authorization", "bearer <token>");
req.Headers.Add("User-Agent", "my-integration/1.0");
req.Content = new StringContent(@"[{""id"": ""00000000-0000-0000-0000-000000000000""}]", Encoding.UTF8, "application/json");

var response = await client.SendAsync(req);
var data = await response.Content.ReadAsStringAsync();
Response200
[]
CREATE FROM SHIPPABLE PACKAGES
POST/create-from-shippable-packagesCreate an order from shippable packages.

Create an order with packages that contain shipment properties.

Responses
StatusDescription
200The request is successfully accepted.
400Invalid request syntax
RequestPOST /create-from-shippable-packages
curl -X POST 'https://order.api.myparcel.nl/create-from-shippable-packages' \
  -H 'Authorization: bearer <token>' \
  -H 'User-Agent: my-integration/1.0' \
  -H 'Content-Type: application/json' \
  -d '[]'
<?php
$ch = curl_init("https://order.api.myparcel.nl/create-from-shippable-packages");
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST  => 'POST',
    CURLOPT_POSTFIELDS     => json_encode([]),
    CURLOPT_HTTPHEADER     => [
        'Authorization: bearer <token>',
        'User-Agent: my-integration/1.0',
        'Content-Type: application/json',
    ],
]);

$response = json_decode(curl_exec($ch), true);
const response = await fetch("https://order.api.myparcel.nl/create-from-shippable-packages", {
  method: 'POST',
  headers: {
    Authorization: 'bearer <token>',
    'User-Agent': 'my-integration/1.0',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify([]),
});

const data = await response.json();
import requests

headers = {"Authorization": "bearer <token>", "User-Agent": "my-integration/1.0"}

payload = []

response = requests.post("https://order.api.myparcel.nl/create-from-shippable-packages", json=payload, headers=headers)

data = response.json()
require 'net/http'
require 'json'
require 'uri'

uri = URI('https://order.api.myparcel.nl/create-from-shippable-packages')
req = Net::HTTP::Post.new(uri)
req['Authorization'] = 'bearer <token>'
req['User-Agent'] = 'my-integration/1.0'
req['Content-Type'] = 'application/json'
req.body = "[]"

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
data = JSON.parse(res.body)
package main

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

func main() {
	payload := []byte(`[]`)
	req, _ := http.NewRequest("POST", "https://order.api.myparcel.nl/create-from-shippable-packages", bytes.NewBuffer(payload))
	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("Authorization", "bearer <token>")
	req.Header.Set("User-Agent", "my-integration/1.0")

	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)
	fmt.Println(string(body))
}
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Example {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest req = HttpRequest.newBuilder()
            .uri(URI.create("https://order.api.myparcel.nl/create-from-shippable-packages"))
            .header("Authorization", "bearer <token>")
            .header("User-Agent", "my-integration/1.0")
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString("[]"))
            .build();

        HttpResponse<String> res = client.send(req, HttpResponse.BodyHandlers.ofString());
        System.out.println(res.body());
    }
}
using System.Net.Http;
using System.Text;

var client = new HttpClient();
var req = new HttpRequestMessage(HttpMethod.Post, "https://order.api.myparcel.nl/create-from-shippable-packages");
req.Headers.Add("Authorization", "bearer <token>");
req.Headers.Add("User-Agent", "my-integration/1.0");
req.Content = new StringContent(@"[]", Encoding.UTF8, "application/json");

var response = await client.SendAsync(req);
var data = await response.Content.ReadAsStringAsync();
Response200
[]
ADD PACKAGES
POST/add-packagesAdd packages to orders

Add packages to orders

Responses
StatusDescription
200The request is successfully accepted.
400Invalid request syntax
RequestPOST /add-packages
curl -X POST 'https://order.api.myparcel.nl/add-packages' \
  -H 'Authorization: bearer <token>' \
  -H 'User-Agent: my-integration/1.0' \
  -H 'Content-Type: application/json' \
  -d '[
  {
    "id": "00000000-0000-0000-0000-000000000000",
    "packages": [
      {
        "lines": [
          {
            "id": "00000000-0000-0000-0000-000000000000",
            "quantity": 1
          }
        ],
        "physicalProperties": null
      }
    ]
  }
]'
<?php
$ch = curl_init("https://order.api.myparcel.nl/add-packages");
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST  => 'POST',
    CURLOPT_POSTFIELDS     => json_encode([{"id": "00000000-0000-0000-0000-000000000000", "packages": [{"lines": [{"id": "00000000-0000-0000-0000-000000000000", "quantity": 1}], "physicalProperties": null}]}]),
    CURLOPT_HTTPHEADER     => [
        'Authorization: bearer <token>',
        'User-Agent: my-integration/1.0',
        'Content-Type: application/json',
    ],
]);

$response = json_decode(curl_exec($ch), true);
const response = await fetch("https://order.api.myparcel.nl/add-packages", {
  method: 'POST',
  headers: {
    Authorization: 'bearer <token>',
    'User-Agent': 'my-integration/1.0',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify([
    {
      "id": "00000000-0000-0000-0000-000000000000",
      "packages": [
        {
          "lines": [
            {
              "id": "00000000-0000-0000-0000-000000000000",
              "quantity": 1
            }
          ],
          "physicalProperties": null
        }
      ]
    }
  ]),
});

const data = await response.json();
import requests

headers = {"Authorization": "bearer <token>", "User-Agent": "my-integration/1.0"}

payload = [
    {
        "id": "00000000-0000-0000-0000-000000000000",
        "packages": [
            {
                "lines": [
                    {
                        "id": "00000000-0000-0000-0000-000000000000",
                        "quantity": 1
                    }
                ],
                "physicalProperties": null
            }
        ]
    }
]

response = requests.post("https://order.api.myparcel.nl/add-packages", json=payload, headers=headers)

data = response.json()
require 'net/http'
require 'json'
require 'uri'

uri = URI('https://order.api.myparcel.nl/add-packages')
req = Net::HTTP::Post.new(uri)
req['Authorization'] = 'bearer <token>'
req['User-Agent'] = 'my-integration/1.0'
req['Content-Type'] = 'application/json'
req.body = "[{\"id\": \"00000000-0000-0000-0000-000000000000\", \"packages\": [{\"lines\": [{\"id\": \"00000000-0000-0000-0000-000000000000\", \"quantity\": 1}], \"physicalProperties\": null}]}]"

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
data = JSON.parse(res.body)
package main

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

func main() {
	payload := []byte(`[{"id": "00000000-0000-0000-0000-000000000000", "packages": [{"lines": [{"id": "00000000-0000-0000-0000-000000000000", "quantity": 1}], "physicalProperties": null}]}]`)
	req, _ := http.NewRequest("POST", "https://order.api.myparcel.nl/add-packages", bytes.NewBuffer(payload))
	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("Authorization", "bearer <token>")
	req.Header.Set("User-Agent", "my-integration/1.0")

	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)
	fmt.Println(string(body))
}
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Example {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest req = HttpRequest.newBuilder()
            .uri(URI.create("https://order.api.myparcel.nl/add-packages"))
            .header("Authorization", "bearer <token>")
            .header("User-Agent", "my-integration/1.0")
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString("[{\"id\": \"00000000-0000-0000-0000-000000000000\", \"packages\": [{\"lines\": [{\"id\": \"00000000-0000-0000-0000-000000000000\", \"quantity\": 1}], \"physicalProperties\": null}]}]"))
            .build();

        HttpResponse<String> res = client.send(req, HttpResponse.BodyHandlers.ofString());
        System.out.println(res.body());
    }
}
using System.Net.Http;
using System.Text;

var client = new HttpClient();
var req = new HttpRequestMessage(HttpMethod.Post, "https://order.api.myparcel.nl/add-packages");
req.Headers.Add("Authorization", "bearer <token>");
req.Headers.Add("User-Agent", "my-integration/1.0");
req.Content = new StringContent(@"[{""id"": ""00000000-0000-0000-0000-000000000000"", ""packages"": [{""lines"": [{""id"": ""00000000-0000-0000-0000-000000000000"", ""quantity"": 1}], ""physicalProperties"": null}]}]", Encoding.UTF8, "application/json");

var response = await client.SendAsync(req);
var data = await response.Content.ReadAsStringAsync();
Response200
[]
PREPARE PACKAGES FOR SHIPMENT
POST/prepare-packages-for-shipmentPrepares packages for shipment

Prepares packages for shipment

Responses
StatusDescription
200The request is successfully accepted.
400Invalid request syntax
RequestPOST /prepare-packages-for-shipment
curl -X POST 'https://order.api.myparcel.nl/prepare-packages-for-shipment' \
  -H 'Authorization: bearer <token>' \
  -H 'User-Agent: my-integration/1.0' \
  -H 'Content-Type: application/json' \
  -d '[]'
<?php
$ch = curl_init("https://order.api.myparcel.nl/prepare-packages-for-shipment");
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST  => 'POST',
    CURLOPT_POSTFIELDS     => json_encode([]),
    CURLOPT_HTTPHEADER     => [
        'Authorization: bearer <token>',
        'User-Agent: my-integration/1.0',
        'Content-Type: application/json',
    ],
]);

$response = json_decode(curl_exec($ch), true);
const response = await fetch("https://order.api.myparcel.nl/prepare-packages-for-shipment", {
  method: 'POST',
  headers: {
    Authorization: 'bearer <token>',
    'User-Agent': 'my-integration/1.0',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify([]),
});

const data = await response.json();
import requests

headers = {"Authorization": "bearer <token>", "User-Agent": "my-integration/1.0"}

payload = []

response = requests.post("https://order.api.myparcel.nl/prepare-packages-for-shipment", json=payload, headers=headers)

data = response.json()
require 'net/http'
require 'json'
require 'uri'

uri = URI('https://order.api.myparcel.nl/prepare-packages-for-shipment')
req = Net::HTTP::Post.new(uri)
req['Authorization'] = 'bearer <token>'
req['User-Agent'] = 'my-integration/1.0'
req['Content-Type'] = 'application/json'
req.body = "[]"

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
data = JSON.parse(res.body)
package main

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

func main() {
	payload := []byte(`[]`)
	req, _ := http.NewRequest("POST", "https://order.api.myparcel.nl/prepare-packages-for-shipment", bytes.NewBuffer(payload))
	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("Authorization", "bearer <token>")
	req.Header.Set("User-Agent", "my-integration/1.0")

	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)
	fmt.Println(string(body))
}
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Example {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest req = HttpRequest.newBuilder()
            .uri(URI.create("https://order.api.myparcel.nl/prepare-packages-for-shipment"))
            .header("Authorization", "bearer <token>")
            .header("User-Agent", "my-integration/1.0")
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString("[]"))
            .build();

        HttpResponse<String> res = client.send(req, HttpResponse.BodyHandlers.ofString());
        System.out.println(res.body());
    }
}
using System.Net.Http;
using System.Text;

var client = new HttpClient();
var req = new HttpRequestMessage(HttpMethod.Post, "https://order.api.myparcel.nl/prepare-packages-for-shipment");
req.Headers.Add("Authorization", "bearer <token>");
req.Headers.Add("User-Agent", "my-integration/1.0");
req.Content = new StringContent(@"[]", Encoding.UTF8, "application/json");

var response = await client.SendAsync(req);
var data = await response.Content.ReadAsStringAsync();
Response200
[]
UNPREPARE PACKAGES FOR SHIPMENT
POST/unprepare-packages-for-shipmentUnprepares packages for shipment

Unprepares packages for shipment. Only possible if the order has status=OPEN.

Responses
StatusDescription
200The request is successfully accepted.
400Invalid request syntax
RequestPOST /unprepare-packages-for-shipment
curl -X POST 'https://order.api.myparcel.nl/unprepare-packages-for-shipment' \
  -H 'Authorization: bearer <token>' \
  -H 'User-Agent: my-integration/1.0' \
  -H 'Content-Type: application/json' \
  -d '[
  {
    "id": "00000000-0000-0000-0000-000000000000",
    "packageIds": [
      "00000000-0000-0000-0000-000000000000"
    ]
  }
]'
<?php
$ch = curl_init("https://order.api.myparcel.nl/unprepare-packages-for-shipment");
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST  => 'POST',
    CURLOPT_POSTFIELDS     => json_encode([{"id": "00000000-0000-0000-0000-000000000000", "packageIds": ["00000000-0000-0000-0000-000000000000"]}]),
    CURLOPT_HTTPHEADER     => [
        'Authorization: bearer <token>',
        'User-Agent: my-integration/1.0',
        'Content-Type: application/json',
    ],
]);

$response = json_decode(curl_exec($ch), true);
const response = await fetch("https://order.api.myparcel.nl/unprepare-packages-for-shipment", {
  method: 'POST',
  headers: {
    Authorization: 'bearer <token>',
    'User-Agent': 'my-integration/1.0',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify([
    {
      "id": "00000000-0000-0000-0000-000000000000",
      "packageIds": [
        "00000000-0000-0000-0000-000000000000"
      ]
    }
  ]),
});

const data = await response.json();
import requests

headers = {"Authorization": "bearer <token>", "User-Agent": "my-integration/1.0"}

payload = [
    {
        "id": "00000000-0000-0000-0000-000000000000",
        "packageIds": [
            "00000000-0000-0000-0000-000000000000"
        ]
    }
]

response = requests.post("https://order.api.myparcel.nl/unprepare-packages-for-shipment", json=payload, headers=headers)

data = response.json()
require 'net/http'
require 'json'
require 'uri'

uri = URI('https://order.api.myparcel.nl/unprepare-packages-for-shipment')
req = Net::HTTP::Post.new(uri)
req['Authorization'] = 'bearer <token>'
req['User-Agent'] = 'my-integration/1.0'
req['Content-Type'] = 'application/json'
req.body = "[{\"id\": \"00000000-0000-0000-0000-000000000000\", \"packageIds\": [\"00000000-0000-0000-0000-000000000000\"]}]"

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
data = JSON.parse(res.body)
package main

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

func main() {
	payload := []byte(`[{"id": "00000000-0000-0000-0000-000000000000", "packageIds": ["00000000-0000-0000-0000-000000000000"]}]`)
	req, _ := http.NewRequest("POST", "https://order.api.myparcel.nl/unprepare-packages-for-shipment", bytes.NewBuffer(payload))
	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("Authorization", "bearer <token>")
	req.Header.Set("User-Agent", "my-integration/1.0")

	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)
	fmt.Println(string(body))
}
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Example {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest req = HttpRequest.newBuilder()
            .uri(URI.create("https://order.api.myparcel.nl/unprepare-packages-for-shipment"))
            .header("Authorization", "bearer <token>")
            .header("User-Agent", "my-integration/1.0")
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString("[{\"id\": \"00000000-0000-0000-0000-000000000000\", \"packageIds\": [\"00000000-0000-0000-0000-000000000000\"]}]"))
            .build();

        HttpResponse<String> res = client.send(req, HttpResponse.BodyHandlers.ofString());
        System.out.println(res.body());
    }
}
using System.Net.Http;
using System.Text;

var client = new HttpClient();
var req = new HttpRequestMessage(HttpMethod.Post, "https://order.api.myparcel.nl/unprepare-packages-for-shipment");
req.Headers.Add("Authorization", "bearer <token>");
req.Headers.Add("User-Agent", "my-integration/1.0");
req.Content = new StringContent(@"[{""id"": ""00000000-0000-0000-0000-000000000000"", ""packageIds"": [""00000000-0000-0000-0000-000000000000""]}]", Encoding.UTF8, "application/json");

var response = await client.SendAsync(req);
var data = await response.Content.ReadAsStringAsync();
Response200
[]
EDIT NOTE
POST/edit-noteEdit a note of an order.

Edit order note. Only possible if the order has status=OPEN.

Responses
StatusDescription
200The request is successfully accepted.
400Invalid request syntax
RequestPOST /edit-note
curl -X POST 'https://order.api.myparcel.nl/edit-note' \
  -H 'Authorization: bearer <token>' \
  -H 'User-Agent: my-integration/1.0' \
  -H 'Content-Type: application/json' \
  -d '[
  {
    "id": "00000000-0000-0000-0000-000000000000",
    "noteId": "00000000-0000-0000-0000-000000000000",
    "text": "string"
  }
]'
<?php
$ch = curl_init("https://order.api.myparcel.nl/edit-note");
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST  => 'POST',
    CURLOPT_POSTFIELDS     => json_encode([{"id": "00000000-0000-0000-0000-000000000000", "noteId": "00000000-0000-0000-0000-000000000000", "text": "string"}]),
    CURLOPT_HTTPHEADER     => [
        'Authorization: bearer <token>',
        'User-Agent: my-integration/1.0',
        'Content-Type: application/json',
    ],
]);

$response = json_decode(curl_exec($ch), true);
const response = await fetch("https://order.api.myparcel.nl/edit-note", {
  method: 'POST',
  headers: {
    Authorization: 'bearer <token>',
    'User-Agent': 'my-integration/1.0',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify([
    {
      "id": "00000000-0000-0000-0000-000000000000",
      "noteId": "00000000-0000-0000-0000-000000000000",
      "text": "string"
    }
  ]),
});

const data = await response.json();
import requests

headers = {"Authorization": "bearer <token>", "User-Agent": "my-integration/1.0"}

payload = [
    {
        "id": "00000000-0000-0000-0000-000000000000",
        "noteId": "00000000-0000-0000-0000-000000000000",
        "text": "string"
    }
]

response = requests.post("https://order.api.myparcel.nl/edit-note", json=payload, headers=headers)

data = response.json()
require 'net/http'
require 'json'
require 'uri'

uri = URI('https://order.api.myparcel.nl/edit-note')
req = Net::HTTP::Post.new(uri)
req['Authorization'] = 'bearer <token>'
req['User-Agent'] = 'my-integration/1.0'
req['Content-Type'] = 'application/json'
req.body = "[{\"id\": \"00000000-0000-0000-0000-000000000000\", \"noteId\": \"00000000-0000-0000-0000-000000000000\", \"text\": \"string\"}]"

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
data = JSON.parse(res.body)
package main

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

func main() {
	payload := []byte(`[{"id": "00000000-0000-0000-0000-000000000000", "noteId": "00000000-0000-0000-0000-000000000000", "text": "string"}]`)
	req, _ := http.NewRequest("POST", "https://order.api.myparcel.nl/edit-note", bytes.NewBuffer(payload))
	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("Authorization", "bearer <token>")
	req.Header.Set("User-Agent", "my-integration/1.0")

	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)
	fmt.Println(string(body))
}
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Example {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest req = HttpRequest.newBuilder()
            .uri(URI.create("https://order.api.myparcel.nl/edit-note"))
            .header("Authorization", "bearer <token>")
            .header("User-Agent", "my-integration/1.0")
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString("[{\"id\": \"00000000-0000-0000-0000-000000000000\", \"noteId\": \"00000000-0000-0000-0000-000000000000\", \"text\": \"string\"}]"))
            .build();

        HttpResponse<String> res = client.send(req, HttpResponse.BodyHandlers.ofString());
        System.out.println(res.body());
    }
}
using System.Net.Http;
using System.Text;

var client = new HttpClient();
var req = new HttpRequestMessage(HttpMethod.Post, "https://order.api.myparcel.nl/edit-note");
req.Headers.Add("Authorization", "bearer <token>");
req.Headers.Add("User-Agent", "my-integration/1.0");
req.Content = new StringContent(@"[{""id"": ""00000000-0000-0000-0000-000000000000"", ""noteId"": ""00000000-0000-0000-0000-000000000000"", ""text"": ""string""}]", Encoding.UTF8, "application/json");

var response = await client.SendAsync(req);
var data = await response.Content.ReadAsStringAsync();
Response200
[]
IMPORT
POST/importImport an order after it is discovered from a sales channel.

Import a discovered order. Only possible if the order has status=DISCOVERED.

Responses
StatusDescription
200The request is successfully accepted.
400Invalid request syntax
RequestPOST /import
curl -X POST 'https://order.api.myparcel.nl/import' \
  -H 'Authorization: bearer <token>' \
  -H 'User-Agent: my-integration/1.0' \
  -H 'Content-Type: application/json' \
  -d '[
  {
    "id": "00000000-0000-0000-0000-000000000000"
  }
]'
<?php
$ch = curl_init("https://order.api.myparcel.nl/import");
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST  => 'POST',
    CURLOPT_POSTFIELDS     => json_encode([{"id": "00000000-0000-0000-0000-000000000000"}]),
    CURLOPT_HTTPHEADER     => [
        'Authorization: bearer <token>',
        'User-Agent: my-integration/1.0',
        'Content-Type: application/json',
    ],
]);

$response = json_decode(curl_exec($ch), true);
const response = await fetch("https://order.api.myparcel.nl/import", {
  method: 'POST',
  headers: {
    Authorization: 'bearer <token>',
    'User-Agent': 'my-integration/1.0',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify([
    {
      "id": "00000000-0000-0000-0000-000000000000"
    }
  ]),
});

const data = await response.json();
import requests

headers = {"Authorization": "bearer <token>", "User-Agent": "my-integration/1.0"}

payload = [
    {
        "id": "00000000-0000-0000-0000-000000000000"
    }
]

response = requests.post("https://order.api.myparcel.nl/import", json=payload, headers=headers)

data = response.json()
require 'net/http'
require 'json'
require 'uri'

uri = URI('https://order.api.myparcel.nl/import')
req = Net::HTTP::Post.new(uri)
req['Authorization'] = 'bearer <token>'
req['User-Agent'] = 'my-integration/1.0'
req['Content-Type'] = 'application/json'
req.body = "[{\"id\": \"00000000-0000-0000-0000-000000000000\"}]"

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
data = JSON.parse(res.body)
package main

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

func main() {
	payload := []byte(`[{"id": "00000000-0000-0000-0000-000000000000"}]`)
	req, _ := http.NewRequest("POST", "https://order.api.myparcel.nl/import", bytes.NewBuffer(payload))
	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("Authorization", "bearer <token>")
	req.Header.Set("User-Agent", "my-integration/1.0")

	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)
	fmt.Println(string(body))
}
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Example {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest req = HttpRequest.newBuilder()
            .uri(URI.create("https://order.api.myparcel.nl/import"))
            .header("Authorization", "bearer <token>")
            .header("User-Agent", "my-integration/1.0")
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString("[{\"id\": \"00000000-0000-0000-0000-000000000000\"}]"))
            .build();

        HttpResponse<String> res = client.send(req, HttpResponse.BodyHandlers.ofString());
        System.out.println(res.body());
    }
}
using System.Net.Http;
using System.Text;

var client = new HttpClient();
var req = new HttpRequestMessage(HttpMethod.Post, "https://order.api.myparcel.nl/import");
req.Headers.Add("Authorization", "bearer <token>");
req.Headers.Add("User-Agent", "my-integration/1.0");
req.Content = new StringContent(@"[{""id"": ""00000000-0000-0000-0000-000000000000""}]", Encoding.UTF8, "application/json");

var response = await client.SendAsync(req);
var data = await response.Content.ReadAsStringAsync();
Response200
[]
ORDERS
GET/ordersQuery and/or filter orders.

Get orders.

Parameters
NameTypeDescription
aggregationarrayFields to summarize data for based on the query.
filterobject
limitintegerThe maximum number of orders to retrieve.
pageTokenstringThe page token to retrieve the next page of orders.
querystringThe following operators are supported: '+ signifies AND operation' '| signifies OR operation' '- negates a single token' '" wraps a number of tokens to signify a phrase for searching' '* at the end of a term signifies a prefix query' '( and ) signify precedence' '~N after a word signifies edit distance (fuzziness)' '~N after a phrase signifies slop amount' To use one of these characters literally, escape it with a preceding backslash (\).
sortobjectWhen no `query` is provided the default sort is by `orderedAt` descending. When a `query` is provided the default sort is by relevance.
Responses
StatusDescription
200The found orders.
400Invalid request syntax
RequestGET /orders
curl -X GET 'https://order.api.myparcel.nl/orders?aggregation=value' \
  -H 'Authorization: bearer <token>' \
  -H 'User-Agent: my-integration/1.0'
<?php
$ch = curl_init("https://order.api.myparcel.nl/orders?aggregation=value");
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER     => [
        'Authorization: bearer <token>',
        'User-Agent: my-integration/1.0',
    ],
]);

$response = json_decode(curl_exec($ch), true);
const response = await fetch("https://order.api.myparcel.nl/orders?aggregation=value", {
  headers: {
    Authorization: 'bearer <token>',
    'User-Agent': 'my-integration/1.0',
  },
});

const data = await response.json();
import requests

headers = {"Authorization": "bearer <token>", "User-Agent": "my-integration/1.0"}

params = {
    "aggregation": "value"
}

response = requests.get("https://order.api.myparcel.nl/orders", params=params, headers=headers)

data = response.json()
require 'net/http'
require 'json'
require 'uri'

uri = URI('https://order.api.myparcel.nl/orders?aggregation=value')
req = Net::HTTP::Get.new(uri)
req['Authorization'] = 'bearer <token>'
req['User-Agent'] = 'my-integration/1.0'

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
data = JSON.parse(res.body)
package main

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

func main() {
	req, _ := http.NewRequest("GET", "https://order.api.myparcel.nl/orders?aggregation=value", nil)
	req.Header.Set("Authorization", "bearer <token>")
	req.Header.Set("User-Agent", "my-integration/1.0")

	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)
	fmt.Println(string(body))
}
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Example {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest req = HttpRequest.newBuilder()
            .uri(URI.create("https://order.api.myparcel.nl/orders?aggregation=value"))
            .header("Authorization", "bearer <token>")
            .header("User-Agent", "my-integration/1.0")
            .GET()
            .build();

        HttpResponse<String> res = client.send(req, HttpResponse.BodyHandlers.ofString());
        System.out.println(res.body());
    }
}
using System.Net.Http;
using System.Text;

var client = new HttpClient();
var req = new HttpRequestMessage(HttpMethod.Get, "https://order.api.myparcel.nl/orders?aggregation=value");
req.Headers.Add("Authorization", "bearer <token>");
req.Headers.Add("User-Agent", "my-integration/1.0");

var response = await client.SendAsync(req);
var data = await response.Content.ReadAsStringAsync();
Response200
{
  "results": [
    {
      "id": "00000000-0000-0000-0000-000000000000",
      "orderedAt": null,
      "price": {
        "currency": "string",
        "fractional": 1,
        "integral": 1
      },
      "shopId": "string",
      "status": "CANCELED"
    }
  ],
  "total": {
    "relation": "eq",
    "value": 1
  }
}
PACKING SLIPS
GET/packing-slipsGenerate packing slips for 1 or more orders.

Get packing slips for one or more orders. When packageId is provided, exactly one orderId must be supplied and the packageIds must belong to that order.

Parameters
NameTypeDescription
shipmentLabelsLayoutstringHow shipment labels are included alongside the packing slips in the resulting PDF. `INTERLEAVED` outputs each packing slip immediately followed by its shipment label. When the parameter is omitted, no shipment labels are included and only packing slips are rendered.
Values: INTERLEAVED
orderIdREQUIREDarrayThe orderId of the order to include in the packing slips. A maximum of 50 orders can be included in the request. When packageId is provided, exactly one orderId is allowed.
packageIdarrayThe packageId of the package to include in the packing slips. The packageIds must belong to the single orderId in the request and a maximum of 20 packageIds can be included.
Accept (header)REQUIREDstring
Values: application/pdf
Responses
StatusDescription
200Packing slips PDF.
400Invalid request syntax
RequestGET /packing-slips
curl -X GET 'https://order.api.myparcel.nl/packing-slips?orderId=value' \
  -H 'Authorization: bearer <token>' \
  -H 'User-Agent: my-integration/1.0'
<?php
$ch = curl_init("https://order.api.myparcel.nl/packing-slips?orderId=value");
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER     => [
        'Authorization: bearer <token>',
        'User-Agent: my-integration/1.0',
    ],
]);

$response = json_decode(curl_exec($ch), true);
const response = await fetch("https://order.api.myparcel.nl/packing-slips?orderId=value", {
  headers: {
    Authorization: 'bearer <token>',
    'User-Agent': 'my-integration/1.0',
  },
});

const data = await response.json();
import requests

headers = {"Authorization": "bearer <token>", "User-Agent": "my-integration/1.0"}

params = {
    "orderId": "value"
}

response = requests.get("https://order.api.myparcel.nl/packing-slips", params=params, headers=headers)

data = response.json()
require 'net/http'
require 'json'
require 'uri'

uri = URI('https://order.api.myparcel.nl/packing-slips?orderId=value')
req = Net::HTTP::Get.new(uri)
req['Authorization'] = 'bearer <token>'
req['User-Agent'] = 'my-integration/1.0'

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
data = JSON.parse(res.body)
package main

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

func main() {
	req, _ := http.NewRequest("GET", "https://order.api.myparcel.nl/packing-slips?orderId=value", nil)
	req.Header.Set("Authorization", "bearer <token>")
	req.Header.Set("User-Agent", "my-integration/1.0")

	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)
	fmt.Println(string(body))
}
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Example {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest req = HttpRequest.newBuilder()
            .uri(URI.create("https://order.api.myparcel.nl/packing-slips?orderId=value"))
            .header("Authorization", "bearer <token>")
            .header("User-Agent", "my-integration/1.0")
            .GET()
            .build();

        HttpResponse<String> res = client.send(req, HttpResponse.BodyHandlers.ofString());
        System.out.println(res.body());
    }
}
using System.Net.Http;
using System.Text;

var client = new HttpClient();
var req = new HttpRequestMessage(HttpMethod.Get, "https://order.api.myparcel.nl/packing-slips?orderId=value");
req.Headers.Add("Authorization", "bearer <token>");
req.Headers.Add("User-Agent", "my-integration/1.0");

var response = await client.SendAsync(req);
var data = await response.Content.ReadAsStringAsync();
Response200
"string"
PICKLIST
GET/picklistGenerate a picklist for 1 or more orders.

Get picklist.

Parameters
NameTypeDescription
orderIdREQUIREDarrayThe orderId of the order to include in the picklist. A maximum of 50 orders can be included in the request.
Accept (header)REQUIREDstring
Values: application/pdf
Responses
StatusDescription
200Picklist PDF.
400Invalid request syntax
RequestGET /picklist
curl -X GET 'https://order.api.myparcel.nl/picklist?orderId=value' \
  -H 'Authorization: bearer <token>' \
  -H 'User-Agent: my-integration/1.0'
<?php
$ch = curl_init("https://order.api.myparcel.nl/picklist?orderId=value");
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER     => [
        'Authorization: bearer <token>',
        'User-Agent: my-integration/1.0',
    ],
]);

$response = json_decode(curl_exec($ch), true);
const response = await fetch("https://order.api.myparcel.nl/picklist?orderId=value", {
  headers: {
    Authorization: 'bearer <token>',
    'User-Agent': 'my-integration/1.0',
  },
});

const data = await response.json();
import requests

headers = {"Authorization": "bearer <token>", "User-Agent": "my-integration/1.0"}

params = {
    "orderId": "value"
}

response = requests.get("https://order.api.myparcel.nl/picklist", params=params, headers=headers)

data = response.json()
require 'net/http'
require 'json'
require 'uri'

uri = URI('https://order.api.myparcel.nl/picklist?orderId=value')
req = Net::HTTP::Get.new(uri)
req['Authorization'] = 'bearer <token>'
req['User-Agent'] = 'my-integration/1.0'

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
data = JSON.parse(res.body)
package main

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

func main() {
	req, _ := http.NewRequest("GET", "https://order.api.myparcel.nl/picklist?orderId=value", nil)
	req.Header.Set("Authorization", "bearer <token>")
	req.Header.Set("User-Agent", "my-integration/1.0")

	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)
	fmt.Println(string(body))
}
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Example {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest req = HttpRequest.newBuilder()
            .uri(URI.create("https://order.api.myparcel.nl/picklist?orderId=value"))
            .header("Authorization", "bearer <token>")
            .header("User-Agent", "my-integration/1.0")
            .GET()
            .build();

        HttpResponse<String> res = client.send(req, HttpResponse.BodyHandlers.ofString());
        System.out.println(res.body());
    }
}
using System.Net.Http;
using System.Text;

var client = new HttpClient();
var req = new HttpRequestMessage(HttpMethod.Get, "https://order.api.myparcel.nl/picklist?orderId=value");
req.Headers.Add("Authorization", "bearer <token>");
req.Headers.Add("User-Agent", "my-integration/1.0");

var response = await client.SendAsync(req);
var data = await response.Content.ReadAsStringAsync();
Response200
"string"
REMOVE NOTES
POST/remove-notesRemove notes from an order.

Remove order notes. Only possible if the order has status=OPEN.

Responses
StatusDescription
200The request is successfully accepted.
400Invalid request syntax
RequestPOST /remove-notes
curl -X POST 'https://order.api.myparcel.nl/remove-notes' \
  -H 'Authorization: bearer <token>' \
  -H 'User-Agent: my-integration/1.0' \
  -H 'Content-Type: application/json' \
  -d '[
  {
    "id": "00000000-0000-0000-0000-000000000000",
    "noteIds": [
      "00000000-0000-0000-0000-000000000000"
    ]
  }
]'
<?php
$ch = curl_init("https://order.api.myparcel.nl/remove-notes");
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST  => 'POST',
    CURLOPT_POSTFIELDS     => json_encode([{"id": "00000000-0000-0000-0000-000000000000", "noteIds": ["00000000-0000-0000-0000-000000000000"]}]),
    CURLOPT_HTTPHEADER     => [
        'Authorization: bearer <token>',
        'User-Agent: my-integration/1.0',
        'Content-Type: application/json',
    ],
]);

$response = json_decode(curl_exec($ch), true);
const response = await fetch("https://order.api.myparcel.nl/remove-notes", {
  method: 'POST',
  headers: {
    Authorization: 'bearer <token>',
    'User-Agent': 'my-integration/1.0',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify([
    {
      "id": "00000000-0000-0000-0000-000000000000",
      "noteIds": [
        "00000000-0000-0000-0000-000000000000"
      ]
    }
  ]),
});

const data = await response.json();
import requests

headers = {"Authorization": "bearer <token>", "User-Agent": "my-integration/1.0"}

payload = [
    {
        "id": "00000000-0000-0000-0000-000000000000",
        "noteIds": [
            "00000000-0000-0000-0000-000000000000"
        ]
    }
]

response = requests.post("https://order.api.myparcel.nl/remove-notes", json=payload, headers=headers)

data = response.json()
require 'net/http'
require 'json'
require 'uri'

uri = URI('https://order.api.myparcel.nl/remove-notes')
req = Net::HTTP::Post.new(uri)
req['Authorization'] = 'bearer <token>'
req['User-Agent'] = 'my-integration/1.0'
req['Content-Type'] = 'application/json'
req.body = "[{\"id\": \"00000000-0000-0000-0000-000000000000\", \"noteIds\": [\"00000000-0000-0000-0000-000000000000\"]}]"

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
data = JSON.parse(res.body)
package main

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

func main() {
	payload := []byte(`[{"id": "00000000-0000-0000-0000-000000000000", "noteIds": ["00000000-0000-0000-0000-000000000000"]}]`)
	req, _ := http.NewRequest("POST", "https://order.api.myparcel.nl/remove-notes", bytes.NewBuffer(payload))
	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("Authorization", "bearer <token>")
	req.Header.Set("User-Agent", "my-integration/1.0")

	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)
	fmt.Println(string(body))
}
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Example {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest req = HttpRequest.newBuilder()
            .uri(URI.create("https://order.api.myparcel.nl/remove-notes"))
            .header("Authorization", "bearer <token>")
            .header("User-Agent", "my-integration/1.0")
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString("[{\"id\": \"00000000-0000-0000-0000-000000000000\", \"noteIds\": [\"00000000-0000-0000-0000-000000000000\"]}]"))
            .build();

        HttpResponse<String> res = client.send(req, HttpResponse.BodyHandlers.ofString());
        System.out.println(res.body());
    }
}
using System.Net.Http;
using System.Text;

var client = new HttpClient();
var req = new HttpRequestMessage(HttpMethod.Post, "https://order.api.myparcel.nl/remove-notes");
req.Headers.Add("Authorization", "bearer <token>");
req.Headers.Add("User-Agent", "my-integration/1.0");
req.Content = new StringContent(@"[{""id"": ""00000000-0000-0000-0000-000000000000"", ""noteIds"": [""00000000-0000-0000-0000-000000000000""]}]", Encoding.UTF8, "application/json");

var response = await client.SendAsync(req);
var data = await response.Content.ReadAsStringAsync();
Response200
[]
UNASSIGN FROM USER
POST/unassign-from-userUnassign orders from an user. Only possible if the order has `status=OPEN`

Unassign orders from an user. Only possible if the order has status=OPEN

Responses
StatusDescription
200The request is successfully accepted.
400Invalid request syntax
RequestPOST /unassign-from-user
curl -X POST 'https://order.api.myparcel.nl/unassign-from-user' \
  -H 'Authorization: bearer <token>' \
  -H 'User-Agent: my-integration/1.0' \
  -H 'Content-Type: application/json' \
  -d '[
  {
    "id": "00000000-0000-0000-0000-000000000000"
  }
]'
<?php
$ch = curl_init("https://order.api.myparcel.nl/unassign-from-user");
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST  => 'POST',
    CURLOPT_POSTFIELDS     => json_encode([{"id": "00000000-0000-0000-0000-000000000000"}]),
    CURLOPT_HTTPHEADER     => [
        'Authorization: bearer <token>',
        'User-Agent: my-integration/1.0',
        'Content-Type: application/json',
    ],
]);

$response = json_decode(curl_exec($ch), true);
const response = await fetch("https://order.api.myparcel.nl/unassign-from-user", {
  method: 'POST',
  headers: {
    Authorization: 'bearer <token>',
    'User-Agent': 'my-integration/1.0',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify([
    {
      "id": "00000000-0000-0000-0000-000000000000"
    }
  ]),
});

const data = await response.json();
import requests

headers = {"Authorization": "bearer <token>", "User-Agent": "my-integration/1.0"}

payload = [
    {
        "id": "00000000-0000-0000-0000-000000000000"
    }
]

response = requests.post("https://order.api.myparcel.nl/unassign-from-user", json=payload, headers=headers)

data = response.json()
require 'net/http'
require 'json'
require 'uri'

uri = URI('https://order.api.myparcel.nl/unassign-from-user')
req = Net::HTTP::Post.new(uri)
req['Authorization'] = 'bearer <token>'
req['User-Agent'] = 'my-integration/1.0'
req['Content-Type'] = 'application/json'
req.body = "[{\"id\": \"00000000-0000-0000-0000-000000000000\"}]"

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
data = JSON.parse(res.body)
package main

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

func main() {
	payload := []byte(`[{"id": "00000000-0000-0000-0000-000000000000"}]`)
	req, _ := http.NewRequest("POST", "https://order.api.myparcel.nl/unassign-from-user", bytes.NewBuffer(payload))
	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("Authorization", "bearer <token>")
	req.Header.Set("User-Agent", "my-integration/1.0")

	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)
	fmt.Println(string(body))
}
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Example {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest req = HttpRequest.newBuilder()
            .uri(URI.create("https://order.api.myparcel.nl/unassign-from-user"))
            .header("Authorization", "bearer <token>")
            .header("User-Agent", "my-integration/1.0")
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString("[{\"id\": \"00000000-0000-0000-0000-000000000000\"}]"))
            .build();

        HttpResponse<String> res = client.send(req, HttpResponse.BodyHandlers.ofString());
        System.out.println(res.body());
    }
}
using System.Net.Http;
using System.Text;

var client = new HttpClient();
var req = new HttpRequestMessage(HttpMethod.Post, "https://order.api.myparcel.nl/unassign-from-user");
req.Headers.Add("Authorization", "bearer <token>");
req.Headers.Add("User-Agent", "my-integration/1.0");
req.Content = new StringContent(@"[{""id"": ""00000000-0000-0000-0000-000000000000""}]", Encoding.UTF8, "application/json");

var response = await client.SendAsync(req);
var data = await response.Content.ReadAsStringAsync();
Response200
[]