Super Label GraphQL API

<?php require 'vendor/autoload.php'; $client = new GuzzleHttp\Client(); $response = $client->post('https://api.superlabel.ca/api/graphql', [ 'headers' => [ 'Content-Type' => 'application/json', 'Accept' => 'application/json', 'Authorization' => 'Bearer YOUR_TOKEN', ], 'json' => [ 'query' => 'mutation ChangePassword($current_password: String!, $new_password: String!, $new_confirm_password: String) { changePassword(current_password: $current_password, new_password: $new_password, new_confirm_password: $new_confirm_password) { message } }', 'variables' => json_decode('{"current_password":"example","new_password":"example","new_confirm_password":"example"}', true), ], ]); $data = json_decode($response->getBody(), true); print_r($data);

import requests response = requests.post( 'https://api.superlabel.ca/api/graphql', headers={ 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, json={ 'query': 'mutation ChangePassword($current_password: String!, $new_password: String!, $new_confirm_password: String) { changePassword(current_password: $current_password, new_password: $new_password, new_confirm_password: $new_confirm_password) { message } }', 'variables': {"current_password":"example","new_password":"example","new_confirm_password":"example"}, }, ) data = response.json() print(data)

package main import ( "bytes" "encoding/json" "fmt" "io" "net/http" ) func main() { payload, _ := json.Marshal(map[string]interface{}{ "query": `mutation ChangePassword($current_password: String!, $new_password: String!, $new_confirm_password: String) { changePassword(current_password: $current_password, new_password: $new_password, new_confirm_password: $new_confirm_password) { message } }`, "variables": {"current_password":"example","new_password":"example","new_confirm_password":"example"}, }) req, _ := http.NewRequest("POST", "https://api.superlabel.ca/api/graphql", bytes.NewBuffer(payload)) req.Header.Set("Content-Type", "application/json") req.Header.Set("Accept", "application/json") req.Header.Set("Authorization", "Bearer YOUR_TOKEN") client := &http.Client{} resp, _ := client.Do(req) defer resp.Body.Close() body, _ := io.ReadAll(resp.Body) fmt.Println(string(body)) }

const response = await fetch('https://api.superlabel.ca/api/graphql', { method: 'POST', headers: { 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, body: JSON.stringify({ query: `mutation ChangePassword($current_password: String!, $new_password: String!, $new_confirm_password: String) { changePassword(current_password: $current_password, new_password: $new_password, new_confirm_password: $new_confirm_password) { message } }`, variables: { "current_password": "example", "new_password": "example", "new_confirm_password": "example" }, }), }); const data = await response.json(); console.log(data);

import java.net.http.*; import java.net.URI; HttpClient client = HttpClient.newHttpClient(); String body = "{\"query\":\"mutation ChangePassword($current_password: String!, $new_password: String!, $new_confirm_password: String) {\\n changePassword(current_password: $current_password, new_password: $new_password, new_confirm_password: $new_confirm_password) {\\n message\\n}\\n}\",\"variables\":{\"current_password\":\"example\",\"new_password\":\"example\",\"new_confirm_password\":\"example\"}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.superlabel.ca/api/graphql")) .header("Content-Type", "application/json") .header("Accept", "application/json") .header("Authorization", "Bearer YOUR_TOKEN") .POST(HttpRequest.BodyPublishers.ofString(body)) .build(); HttpResponse<String> response = client.send( request, HttpResponse.BodyHandlers.ofString() ); System.out.println(response.body());

require 'net/http' require 'json' require 'uri' uri = URI.parse('https://api.superlabel.ca/api/graphql') http = Net::HTTP.new(uri.host, uri.port) http.use_ssl = uri.scheme == 'https' request = Net::HTTP::Post.new(uri) request.content_type = 'application/json' request['Accept'] = 'application/json' request['Authorization'] = 'Bearer YOUR_TOKEN' request.body = JSON.dump({ query: 'mutation ChangePassword($current_password: String!, $new_password: String!, $new_confirm_password: String) { changePassword(current_password: $current_password, new_password: $new_password, new_confirm_password: $new_confirm_password) { message } }', variables: {"current_password":"example","new_password":"example","new_confirm_password":"example"} }) response = http.request(request) puts JSON.parse(response.body)

<?php require 'vendor/autoload.php'; $client = new GuzzleHttp\Client(); $response = $client->post('https://api.superlabel.ca/api/graphql', [ 'headers' => [ 'Content-Type' => 'application/json', 'Accept' => 'application/json', ], 'json' => [ 'query' => 'mutation UserLogin($email: String!, $password: String!, $remember_me: Boolean, $is_flexmesh: Boolean, $include_price_markup: Boolean) { userLogin(email: $email, password: $password, remember_me: $remember_me, is_flexmesh: $is_flexmesh, include_price_markup: $include_price_markup) { result access_token token_type expires_at expires_timestamp name email message label_service_price_markup label_service_price_markup_details } }', 'variables' => json_decode('{"email":"user@example.com","password":"example","remember_me":true,"is_flexmesh":true,"include_price_markup":true}', true), ], ]); $data = json_decode($response->getBody(), true); print_r($data);

import requests response = requests.post( 'https://api.superlabel.ca/api/graphql', headers={ 'Content-Type': 'application/json', 'Accept': 'application/json', }, json={ 'query': 'mutation UserLogin($email: String!, $password: String!, $remember_me: Boolean, $is_flexmesh: Boolean, $include_price_markup: Boolean) { userLogin(email: $email, password: $password, remember_me: $remember_me, is_flexmesh: $is_flexmesh, include_price_markup: $include_price_markup) { result access_token token_type expires_at expires_timestamp name email message label_service_price_markup label_service_price_markup_details } }', 'variables': {"email":"user@example.com","password":"example","remember_me":true,"is_flexmesh":true,"include_price_markup":true}, }, ) data = response.json() print(data)

package main import ( "bytes" "encoding/json" "fmt" "io" "net/http" ) func main() { payload, _ := json.Marshal(map[string]interface{}{ "query": `mutation UserLogin($email: String!, $password: String!, $remember_me: Boolean, $is_flexmesh: Boolean, $include_price_markup: Boolean) { userLogin(email: $email, password: $password, remember_me: $remember_me, is_flexmesh: $is_flexmesh, include_price_markup: $include_price_markup) { result access_token token_type expires_at expires_timestamp name email message label_service_price_markup label_service_price_markup_details } }`, "variables": {"email":"user@example.com","password":"example","remember_me":true,"is_flexmesh":true,"include_price_markup":true}, }) req, _ := http.NewRequest("POST", "https://api.superlabel.ca/api/graphql", bytes.NewBuffer(payload)) req.Header.Set("Content-Type", "application/json") req.Header.Set("Accept", "application/json") client := &http.Client{} resp, _ := client.Do(req) defer resp.Body.Close() body, _ := io.ReadAll(resp.Body) fmt.Println(string(body)) }

const response = await fetch('https://api.superlabel.ca/api/graphql', { method: 'POST', headers: { 'Content-Type': 'application/json', 'Accept': 'application/json', }, body: JSON.stringify({ query: `mutation UserLogin($email: String!, $password: String!, $remember_me: Boolean, $is_flexmesh: Boolean, $include_price_markup: Boolean) { userLogin(email: $email, password: $password, remember_me: $remember_me, is_flexmesh: $is_flexmesh, include_price_markup: $include_price_markup) { result access_token token_type expires_at expires_timestamp name email message label_service_price_markup label_service_price_markup_details } }`, variables: { "email": "user@example.com", "password": "example", "remember_me": true, "is_flexmesh": true, "include_price_markup": true }, }), }); const data = await response.json(); console.log(data);

import java.net.http.*; import java.net.URI; HttpClient client = HttpClient.newHttpClient(); String body = "{\"query\":\"mutation UserLogin($email: String!, $password: String!, $remember_me: Boolean, $is_flexmesh: Boolean, $include_price_markup: Boolean) {\\n userLogin(email: $email, password: $password, remember_me: $remember_me, is_flexmesh: $is_flexmesh, include_price_markup: $include_price_markup) {\\n result\\n access_token\\n token_type\\n expires_at\\n expires_timestamp\\n name\\n email\\n message\\n label_service_price_markup\\n label_service_price_markup_details\\n}\\n}\",\"variables\":{\"email\":\"user@example.com\",\"password\":\"example\",\"remember_me\":true,\"is_flexmesh\":true,\"include_price_markup\":true}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.superlabel.ca/api/graphql")) .header("Content-Type", "application/json") .header("Accept", "application/json") .POST(HttpRequest.BodyPublishers.ofString(body)) .build(); HttpResponse<String> response = client.send( request, HttpResponse.BodyHandlers.ofString() ); System.out.println(response.body());

require 'net/http' require 'json' require 'uri' uri = URI.parse('https://api.superlabel.ca/api/graphql') http = Net::HTTP.new(uri.host, uri.port) http.use_ssl = uri.scheme == 'https' request = Net::HTTP::Post.new(uri) request.content_type = 'application/json' request['Accept'] = 'application/json' request.body = JSON.dump({ query: 'mutation UserLogin($email: String!, $password: String!, $remember_me: Boolean, $is_flexmesh: Boolean, $include_price_markup: Boolean) { userLogin(email: $email, password: $password, remember_me: $remember_me, is_flexmesh: $is_flexmesh, include_price_markup: $include_price_markup) { result access_token token_type expires_at expires_timestamp name email message label_service_price_markup label_service_price_markup_details } }', variables: {"email":"user@example.com","password":"example","remember_me":true,"is_flexmesh":true,"include_price_markup":true} }) response = http.request(request) puts JSON.parse(response.body)

<?php require 'vendor/autoload.php'; $client = new GuzzleHttp\Client(); $response = $client->post('https://api.superlabel.ca/api/graphql', [ 'headers' => [ 'Content-Type' => 'application/json', 'Accept' => 'application/json', 'Authorization' => 'Bearer YOUR_TOKEN', ], 'json' => [ 'query' => 'mutation UserRefreshToken { userRefreshToken { result access_token token_type expires_at expires_timestamp name email message label_service_price_markup label_service_price_markup_details } }', 'variables' => [], ], ]); $data = json_decode($response->getBody(), true); print_r($data);

import requests response = requests.post( 'https://api.superlabel.ca/api/graphql', headers={ 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, json={ 'query': 'mutation UserRefreshToken { userRefreshToken { result access_token token_type expires_at expires_timestamp name email message label_service_price_markup label_service_price_markup_details } }', 'variables': {}, }, ) data = response.json() print(data)

package main import ( "bytes" "encoding/json" "fmt" "io" "net/http" ) func main() { payload, _ := json.Marshal(map[string]interface{}{ "query": `mutation UserRefreshToken { userRefreshToken { result access_token token_type expires_at expires_timestamp name email message label_service_price_markup label_service_price_markup_details } }`, "variables": map[string]interface{}{}, }) req, _ := http.NewRequest("POST", "https://api.superlabel.ca/api/graphql", bytes.NewBuffer(payload)) req.Header.Set("Content-Type", "application/json") req.Header.Set("Accept", "application/json") req.Header.Set("Authorization", "Bearer YOUR_TOKEN") client := &http.Client{} resp, _ := client.Do(req) defer resp.Body.Close() body, _ := io.ReadAll(resp.Body) fmt.Println(string(body)) }

const response = await fetch('https://api.superlabel.ca/api/graphql', { method: 'POST', headers: { 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, body: JSON.stringify({ query: `mutation UserRefreshToken { userRefreshToken { result access_token token_type expires_at expires_timestamp name email message label_service_price_markup label_service_price_markup_details } }`, variables: {}, }), }); const data = await response.json(); console.log(data);

import java.net.http.*; import java.net.URI; HttpClient client = HttpClient.newHttpClient(); String body = "{\"query\":\"mutation UserRefreshToken {\\n userRefreshToken {\\n result\\n access_token\\n token_type\\n expires_at\\n expires_timestamp\\n name\\n email\\n message\\n label_service_price_markup\\n label_service_price_markup_details\\n}\\n}\",\"variables\":{}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.superlabel.ca/api/graphql")) .header("Content-Type", "application/json") .header("Accept", "application/json") .header("Authorization", "Bearer YOUR_TOKEN") .POST(HttpRequest.BodyPublishers.ofString(body)) .build(); HttpResponse<String> response = client.send( request, HttpResponse.BodyHandlers.ofString() ); System.out.println(response.body());

require 'net/http' require 'json' require 'uri' uri = URI.parse('https://api.superlabel.ca/api/graphql') http = Net::HTTP.new(uri.host, uri.port) http.use_ssl = uri.scheme == 'https' request = Net::HTTP::Post.new(uri) request.content_type = 'application/json' request['Accept'] = 'application/json' request['Authorization'] = 'Bearer YOUR_TOKEN' request.body = JSON.dump({ query: 'mutation UserRefreshToken { userRefreshToken { result access_token token_type expires_at expires_timestamp name email message label_service_price_markup label_service_price_markup_details } }', variables: {} }) response = http.request(request) puts JSON.parse(response.body)

<?php require 'vendor/autoload.php'; $client = new GuzzleHttp\Client(); $response = $client->post('https://api.superlabel.ca/api/graphql', [ 'headers' => [ 'Content-Type' => 'application/json', 'Accept' => 'application/json', 'Authorization' => 'Bearer YOUR_TOKEN', ], 'json' => [ 'query' => 'mutation DriverAddGpsTackingRecord($route_id: Int, $order_id: Int, $latitude: String, $longitude: String) { driverAddGpsTackingRecord(route_id: $route_id, order_id: $order_id, latitude: $latitude, longitude: $longitude) }', 'variables' => json_decode('{"route_id":1,"order_id":1,"latitude":"example","longitude":"example"}', true), ], ]); $data = json_decode($response->getBody(), true); print_r($data);

import requests response = requests.post( 'https://api.superlabel.ca/api/graphql', headers={ 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, json={ 'query': 'mutation DriverAddGpsTackingRecord($route_id: Int, $order_id: Int, $latitude: String, $longitude: String) { driverAddGpsTackingRecord(route_id: $route_id, order_id: $order_id, latitude: $latitude, longitude: $longitude) }', 'variables': {"route_id":1,"order_id":1,"latitude":"example","longitude":"example"}, }, ) data = response.json() print(data)

package main import ( "bytes" "encoding/json" "fmt" "io" "net/http" ) func main() { payload, _ := json.Marshal(map[string]interface{}{ "query": `mutation DriverAddGpsTackingRecord($route_id: Int, $order_id: Int, $latitude: String, $longitude: String) { driverAddGpsTackingRecord(route_id: $route_id, order_id: $order_id, latitude: $latitude, longitude: $longitude) }`, "variables": {"route_id":1,"order_id":1,"latitude":"example","longitude":"example"}, }) req, _ := http.NewRequest("POST", "https://api.superlabel.ca/api/graphql", bytes.NewBuffer(payload)) req.Header.Set("Content-Type", "application/json") req.Header.Set("Accept", "application/json") req.Header.Set("Authorization", "Bearer YOUR_TOKEN") client := &http.Client{} resp, _ := client.Do(req) defer resp.Body.Close() body, _ := io.ReadAll(resp.Body) fmt.Println(string(body)) }

const response = await fetch('https://api.superlabel.ca/api/graphql', { method: 'POST', headers: { 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, body: JSON.stringify({ query: `mutation DriverAddGpsTackingRecord($route_id: Int, $order_id: Int, $latitude: String, $longitude: String) { driverAddGpsTackingRecord(route_id: $route_id, order_id: $order_id, latitude: $latitude, longitude: $longitude) }`, variables: { "route_id": 1, "order_id": 1, "latitude": "example", "longitude": "example" }, }), }); const data = await response.json(); console.log(data);

import java.net.http.*; import java.net.URI; HttpClient client = HttpClient.newHttpClient(); String body = "{\"query\":\"mutation DriverAddGpsTackingRecord($route_id: Int, $order_id: Int, $latitude: String, $longitude: String) {\\n driverAddGpsTackingRecord(route_id: $route_id, order_id: $order_id, latitude: $latitude, longitude: $longitude)\\n}\",\"variables\":{\"route_id\":1,\"order_id\":1,\"latitude\":\"example\",\"longitude\":\"example\"}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.superlabel.ca/api/graphql")) .header("Content-Type", "application/json") .header("Accept", "application/json") .header("Authorization", "Bearer YOUR_TOKEN") .POST(HttpRequest.BodyPublishers.ofString(body)) .build(); HttpResponse<String> response = client.send( request, HttpResponse.BodyHandlers.ofString() ); System.out.println(response.body());

require 'net/http' require 'json' require 'uri' uri = URI.parse('https://api.superlabel.ca/api/graphql') http = Net::HTTP.new(uri.host, uri.port) http.use_ssl = uri.scheme == 'https' request = Net::HTTP::Post.new(uri) request.content_type = 'application/json' request['Accept'] = 'application/json' request['Authorization'] = 'Bearer YOUR_TOKEN' request.body = JSON.dump({ query: 'mutation DriverAddGpsTackingRecord($route_id: Int, $order_id: Int, $latitude: String, $longitude: String) { driverAddGpsTackingRecord(route_id: $route_id, order_id: $order_id, latitude: $latitude, longitude: $longitude) }', variables: {"route_id":1,"order_id":1,"latitude":"example","longitude":"example"} }) response = http.request(request) puts JSON.parse(response.body)

<?php require 'vendor/autoload.php'; $client = new GuzzleHttp\Client(); $response = $client->post('https://api.superlabel.ca/api/graphql', [ 'headers' => [ 'Content-Type' => 'application/json', 'Accept' => 'application/json', 'Authorization' => 'Bearer YOUR_TOKEN', ], 'json' => [ 'query' => 'mutation DriverBatchUpdateDeliver($route_id: Int, $order_ids: [Int], $latitude: Float, $longitude: Float, $status_code: String, $photo_urls: [String], $signature_url: String, $signature_note: String, $return_reason_id: Int, $captured_at: String) { driverBatchUpdateDeliver(route_id: $route_id, order_ids: $order_ids, latitude: $latitude, longitude: $longitude, status_code: $status_code, photo_urls: $photo_urls, signature_url: $signature_url, signature_note: $signature_note, return_reason_id: $return_reason_id, captured_at: $captured_at) }', 'variables' => json_decode('{"route_id":1,"order_ids":[1],"latitude":1.5,"longitude":1.5,"status_code":"example","photo_urls":["example"],"signature_url":"example","signature_note":"example","return_reason_id":1,"captured_at":"2026-01-01"}', true), ], ]); $data = json_decode($response->getBody(), true); print_r($data);

import requests response = requests.post( 'https://api.superlabel.ca/api/graphql', headers={ 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, json={ 'query': 'mutation DriverBatchUpdateDeliver($route_id: Int, $order_ids: [Int], $latitude: Float, $longitude: Float, $status_code: String, $photo_urls: [String], $signature_url: String, $signature_note: String, $return_reason_id: Int, $captured_at: String) { driverBatchUpdateDeliver(route_id: $route_id, order_ids: $order_ids, latitude: $latitude, longitude: $longitude, status_code: $status_code, photo_urls: $photo_urls, signature_url: $signature_url, signature_note: $signature_note, return_reason_id: $return_reason_id, captured_at: $captured_at) }', 'variables': {"route_id":1,"order_ids":[1],"latitude":1.5,"longitude":1.5,"status_code":"example","photo_urls":["example"],"signature_url":"example","signature_note":"example","return_reason_id":1,"captured_at":"2026-01-01"}, }, ) data = response.json() print(data)

package main import ( "bytes" "encoding/json" "fmt" "io" "net/http" ) func main() { payload, _ := json.Marshal(map[string]interface{}{ "query": `mutation DriverBatchUpdateDeliver($route_id: Int, $order_ids: [Int], $latitude: Float, $longitude: Float, $status_code: String, $photo_urls: [String], $signature_url: String, $signature_note: String, $return_reason_id: Int, $captured_at: String) { driverBatchUpdateDeliver(route_id: $route_id, order_ids: $order_ids, latitude: $latitude, longitude: $longitude, status_code: $status_code, photo_urls: $photo_urls, signature_url: $signature_url, signature_note: $signature_note, return_reason_id: $return_reason_id, captured_at: $captured_at) }`, "variables": {"route_id":1,"order_ids":[1],"latitude":1.5,"longitude":1.5,"status_code":"example","photo_urls":["example"],"signature_url":"example","signature_note":"example","return_reason_id":1,"captured_at":"2026-01-01"}, }) req, _ := http.NewRequest("POST", "https://api.superlabel.ca/api/graphql", bytes.NewBuffer(payload)) req.Header.Set("Content-Type", "application/json") req.Header.Set("Accept", "application/json") req.Header.Set("Authorization", "Bearer YOUR_TOKEN") client := &http.Client{} resp, _ := client.Do(req) defer resp.Body.Close() body, _ := io.ReadAll(resp.Body) fmt.Println(string(body)) }

const response = await fetch('https://api.superlabel.ca/api/graphql', { method: 'POST', headers: { 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, body: JSON.stringify({ query: `mutation DriverBatchUpdateDeliver($route_id: Int, $order_ids: [Int], $latitude: Float, $longitude: Float, $status_code: String, $photo_urls: [String], $signature_url: String, $signature_note: String, $return_reason_id: Int, $captured_at: String) { driverBatchUpdateDeliver(route_id: $route_id, order_ids: $order_ids, latitude: $latitude, longitude: $longitude, status_code: $status_code, photo_urls: $photo_urls, signature_url: $signature_url, signature_note: $signature_note, return_reason_id: $return_reason_id, captured_at: $captured_at) }`, variables: { "route_id": 1, "order_ids": [ 1 ], "latitude": 1.5, "longitude": 1.5, "status_code": "example", "photo_urls": [ "example" ], "signature_url": "example", "signature_note": "example", "return_reason_id": 1, "captured_at": "2026-01-01" }, }), }); const data = await response.json(); console.log(data);

import java.net.http.*; import java.net.URI; HttpClient client = HttpClient.newHttpClient(); String body = "{\"query\":\"mutation DriverBatchUpdateDeliver($route_id: Int, $order_ids: [Int], $latitude: Float, $longitude: Float, $status_code: String, $photo_urls: [String], $signature_url: String, $signature_note: String, $return_reason_id: Int, $captured_at: String) {\\n driverBatchUpdateDeliver(route_id: $route_id, order_ids: $order_ids, latitude: $latitude, longitude: $longitude, status_code: $status_code, photo_urls: $photo_urls, signature_url: $signature_url, signature_note: $signature_note, return_reason_id: $return_reason_id, captured_at: $captured_at)\\n}\",\"variables\":{\"route_id\":1,\"order_ids\":[1],\"latitude\":1.5,\"longitude\":1.5,\"status_code\":\"example\",\"photo_urls\":[\"example\"],\"signature_url\":\"example\",\"signature_note\":\"example\",\"return_reason_id\":1,\"captured_at\":\"2026-01-01\"}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.superlabel.ca/api/graphql")) .header("Content-Type", "application/json") .header("Accept", "application/json") .header("Authorization", "Bearer YOUR_TOKEN") .POST(HttpRequest.BodyPublishers.ofString(body)) .build(); HttpResponse<String> response = client.send( request, HttpResponse.BodyHandlers.ofString() ); System.out.println(response.body());

require 'net/http' require 'json' require 'uri' uri = URI.parse('https://api.superlabel.ca/api/graphql') http = Net::HTTP.new(uri.host, uri.port) http.use_ssl = uri.scheme == 'https' request = Net::HTTP::Post.new(uri) request.content_type = 'application/json' request['Accept'] = 'application/json' request['Authorization'] = 'Bearer YOUR_TOKEN' request.body = JSON.dump({ query: 'mutation DriverBatchUpdateDeliver($route_id: Int, $order_ids: [Int], $latitude: Float, $longitude: Float, $status_code: String, $photo_urls: [String], $signature_url: String, $signature_note: String, $return_reason_id: Int, $captured_at: String) { driverBatchUpdateDeliver(route_id: $route_id, order_ids: $order_ids, latitude: $latitude, longitude: $longitude, status_code: $status_code, photo_urls: $photo_urls, signature_url: $signature_url, signature_note: $signature_note, return_reason_id: $return_reason_id, captured_at: $captured_at) }', variables: {"route_id":1,"order_ids":[1],"latitude":1.5,"longitude":1.5,"status_code":"example","photo_urls":["example"],"signature_url":"example","signature_note":"example","return_reason_id":1,"captured_at":"2026-01-01"} }) response = http.request(request) puts JSON.parse(response.body)

<?php require 'vendor/autoload.php'; $client = new GuzzleHttp\Client(); $response = $client->post('https://api.superlabel.ca/api/graphql', [ 'headers' => [ 'Content-Type' => 'application/json', 'Accept' => 'application/json', 'Authorization' => 'Bearer YOUR_TOKEN', ], 'json' => [ 'query' => 'mutation DriverCancelRoute($routeId: Int!) { driverCancelRoute(routeId: $routeId) }', 'variables' => json_decode('{"routeId":1}', true), ], ]); $data = json_decode($response->getBody(), true); print_r($data);

import requests response = requests.post( 'https://api.superlabel.ca/api/graphql', headers={ 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, json={ 'query': 'mutation DriverCancelRoute($routeId: Int!) { driverCancelRoute(routeId: $routeId) }', 'variables': {"routeId":1}, }, ) data = response.json() print(data)

package main import ( "bytes" "encoding/json" "fmt" "io" "net/http" ) func main() { payload, _ := json.Marshal(map[string]interface{}{ "query": `mutation DriverCancelRoute($routeId: Int!) { driverCancelRoute(routeId: $routeId) }`, "variables": {"routeId":1}, }) req, _ := http.NewRequest("POST", "https://api.superlabel.ca/api/graphql", bytes.NewBuffer(payload)) req.Header.Set("Content-Type", "application/json") req.Header.Set("Accept", "application/json") req.Header.Set("Authorization", "Bearer YOUR_TOKEN") client := &http.Client{} resp, _ := client.Do(req) defer resp.Body.Close() body, _ := io.ReadAll(resp.Body) fmt.Println(string(body)) }

const response = await fetch('https://api.superlabel.ca/api/graphql', { method: 'POST', headers: { 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, body: JSON.stringify({ query: `mutation DriverCancelRoute($routeId: Int!) { driverCancelRoute(routeId: $routeId) }`, variables: { "routeId": 1 }, }), }); const data = await response.json(); console.log(data);

import java.net.http.*; import java.net.URI; HttpClient client = HttpClient.newHttpClient(); String body = "{\"query\":\"mutation DriverCancelRoute($routeId: Int!) {\\n driverCancelRoute(routeId: $routeId)\\n}\",\"variables\":{\"routeId\":1}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.superlabel.ca/api/graphql")) .header("Content-Type", "application/json") .header("Accept", "application/json") .header("Authorization", "Bearer YOUR_TOKEN") .POST(HttpRequest.BodyPublishers.ofString(body)) .build(); HttpResponse<String> response = client.send( request, HttpResponse.BodyHandlers.ofString() ); System.out.println(response.body());

require 'net/http' require 'json' require 'uri' uri = URI.parse('https://api.superlabel.ca/api/graphql') http = Net::HTTP.new(uri.host, uri.port) http.use_ssl = uri.scheme == 'https' request = Net::HTTP::Post.new(uri) request.content_type = 'application/json' request['Accept'] = 'application/json' request['Authorization'] = 'Bearer YOUR_TOKEN' request.body = JSON.dump({ query: 'mutation DriverCancelRoute($routeId: Int!) { driverCancelRoute(routeId: $routeId) }', variables: {"routeId":1} }) response = http.request(request) puts JSON.parse(response.body)

<?php require 'vendor/autoload.php'; $client = new GuzzleHttp\Client(); $response = $client->post('https://api.superlabel.ca/api/graphql', [ 'headers' => [ 'Content-Type' => 'application/json', 'Accept' => 'application/json', 'Authorization' => 'Bearer YOUR_TOKEN', ], 'json' => [ 'query' => 'mutation DriverCreateRoute($name: String, $service_time: Int, $pickup_time: Int) { driverCreateRoute(name: $name, service_time: $service_time, pickup_time: $pickup_time) }', 'variables' => json_decode('{"name":"example","service_time":1,"pickup_time":1}', true), ], ]); $data = json_decode($response->getBody(), true); print_r($data);

import requests response = requests.post( 'https://api.superlabel.ca/api/graphql', headers={ 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, json={ 'query': 'mutation DriverCreateRoute($name: String, $service_time: Int, $pickup_time: Int) { driverCreateRoute(name: $name, service_time: $service_time, pickup_time: $pickup_time) }', 'variables': {"name":"example","service_time":1,"pickup_time":1}, }, ) data = response.json() print(data)

package main import ( "bytes" "encoding/json" "fmt" "io" "net/http" ) func main() { payload, _ := json.Marshal(map[string]interface{}{ "query": `mutation DriverCreateRoute($name: String, $service_time: Int, $pickup_time: Int) { driverCreateRoute(name: $name, service_time: $service_time, pickup_time: $pickup_time) }`, "variables": {"name":"example","service_time":1,"pickup_time":1}, }) req, _ := http.NewRequest("POST", "https://api.superlabel.ca/api/graphql", bytes.NewBuffer(payload)) req.Header.Set("Content-Type", "application/json") req.Header.Set("Accept", "application/json") req.Header.Set("Authorization", "Bearer YOUR_TOKEN") client := &http.Client{} resp, _ := client.Do(req) defer resp.Body.Close() body, _ := io.ReadAll(resp.Body) fmt.Println(string(body)) }

const response = await fetch('https://api.superlabel.ca/api/graphql', { method: 'POST', headers: { 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, body: JSON.stringify({ query: `mutation DriverCreateRoute($name: String, $service_time: Int, $pickup_time: Int) { driverCreateRoute(name: $name, service_time: $service_time, pickup_time: $pickup_time) }`, variables: { "name": "example", "service_time": 1, "pickup_time": 1 }, }), }); const data = await response.json(); console.log(data);

import java.net.http.*; import java.net.URI; HttpClient client = HttpClient.newHttpClient(); String body = "{\"query\":\"mutation DriverCreateRoute($name: String, $service_time: Int, $pickup_time: Int) {\\n driverCreateRoute(name: $name, service_time: $service_time, pickup_time: $pickup_time)\\n}\",\"variables\":{\"name\":\"example\",\"service_time\":1,\"pickup_time\":1}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.superlabel.ca/api/graphql")) .header("Content-Type", "application/json") .header("Accept", "application/json") .header("Authorization", "Bearer YOUR_TOKEN") .POST(HttpRequest.BodyPublishers.ofString(body)) .build(); HttpResponse<String> response = client.send( request, HttpResponse.BodyHandlers.ofString() ); System.out.println(response.body());

require 'net/http' require 'json' require 'uri' uri = URI.parse('https://api.superlabel.ca/api/graphql') http = Net::HTTP.new(uri.host, uri.port) http.use_ssl = uri.scheme == 'https' request = Net::HTTP::Post.new(uri) request.content_type = 'application/json' request['Accept'] = 'application/json' request['Authorization'] = 'Bearer YOUR_TOKEN' request.body = JSON.dump({ query: 'mutation DriverCreateRoute($name: String, $service_time: Int, $pickup_time: Int) { driverCreateRoute(name: $name, service_time: $service_time, pickup_time: $pickup_time) }', variables: {"name":"example","service_time":1,"pickup_time":1} }) response = http.request(request) puts JSON.parse(response.body)

<?php require 'vendor/autoload.php'; $client = new GuzzleHttp\Client(); $response = $client->post('https://api.superlabel.ca/api/graphql', [ 'headers' => [ 'Content-Type' => 'application/json', 'Accept' => 'application/json', 'Authorization' => 'Bearer YOUR_TOKEN', ], 'json' => [ 'query' => 'mutation DriverDeleteFcmToken { driverDeleteFcmToken }', 'variables' => [], ], ]); $data = json_decode($response->getBody(), true); print_r($data);

import requests response = requests.post( 'https://api.superlabel.ca/api/graphql', headers={ 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, json={ 'query': 'mutation DriverDeleteFcmToken { driverDeleteFcmToken }', 'variables': {}, }, ) data = response.json() print(data)

package main import ( "bytes" "encoding/json" "fmt" "io" "net/http" ) func main() { payload, _ := json.Marshal(map[string]interface{}{ "query": `mutation DriverDeleteFcmToken { driverDeleteFcmToken }`, "variables": map[string]interface{}{}, }) req, _ := http.NewRequest("POST", "https://api.superlabel.ca/api/graphql", bytes.NewBuffer(payload)) req.Header.Set("Content-Type", "application/json") req.Header.Set("Accept", "application/json") req.Header.Set("Authorization", "Bearer YOUR_TOKEN") client := &http.Client{} resp, _ := client.Do(req) defer resp.Body.Close() body, _ := io.ReadAll(resp.Body) fmt.Println(string(body)) }

const response = await fetch('https://api.superlabel.ca/api/graphql', { method: 'POST', headers: { 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, body: JSON.stringify({ query: `mutation DriverDeleteFcmToken { driverDeleteFcmToken }`, variables: {}, }), }); const data = await response.json(); console.log(data);

import java.net.http.*; import java.net.URI; HttpClient client = HttpClient.newHttpClient(); String body = "{\"query\":\"mutation DriverDeleteFcmToken {\\n driverDeleteFcmToken\\n}\",\"variables\":{}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.superlabel.ca/api/graphql")) .header("Content-Type", "application/json") .header("Accept", "application/json") .header("Authorization", "Bearer YOUR_TOKEN") .POST(HttpRequest.BodyPublishers.ofString(body)) .build(); HttpResponse<String> response = client.send( request, HttpResponse.BodyHandlers.ofString() ); System.out.println(response.body());

require 'net/http' require 'json' require 'uri' uri = URI.parse('https://api.superlabel.ca/api/graphql') http = Net::HTTP.new(uri.host, uri.port) http.use_ssl = uri.scheme == 'https' request = Net::HTTP::Post.new(uri) request.content_type = 'application/json' request['Accept'] = 'application/json' request['Authorization'] = 'Bearer YOUR_TOKEN' request.body = JSON.dump({ query: 'mutation DriverDeleteFcmToken { driverDeleteFcmToken }', variables: {} }) response = http.request(request) puts JSON.parse(response.body)

<?php require 'vendor/autoload.php'; $client = new GuzzleHttp\Client(); $response = $client->post('https://api.superlabel.ca/api/graphql', [ 'headers' => [ 'Content-Type' => 'application/json', 'Accept' => 'application/json', 'Authorization' => 'Bearer YOUR_TOKEN', ], 'json' => [ 'query' => 'mutation DriverDeletePictures($id: Int) { driverDeletePictures(id: $id) }', 'variables' => json_decode('{"id":1}', true), ], ]); $data = json_decode($response->getBody(), true); print_r($data);

import requests response = requests.post( 'https://api.superlabel.ca/api/graphql', headers={ 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, json={ 'query': 'mutation DriverDeletePictures($id: Int) { driverDeletePictures(id: $id) }', 'variables': {"id":1}, }, ) data = response.json() print(data)

package main import ( "bytes" "encoding/json" "fmt" "io" "net/http" ) func main() { payload, _ := json.Marshal(map[string]interface{}{ "query": `mutation DriverDeletePictures($id: Int) { driverDeletePictures(id: $id) }`, "variables": {"id":1}, }) req, _ := http.NewRequest("POST", "https://api.superlabel.ca/api/graphql", bytes.NewBuffer(payload)) req.Header.Set("Content-Type", "application/json") req.Header.Set("Accept", "application/json") req.Header.Set("Authorization", "Bearer YOUR_TOKEN") client := &http.Client{} resp, _ := client.Do(req) defer resp.Body.Close() body, _ := io.ReadAll(resp.Body) fmt.Println(string(body)) }

const response = await fetch('https://api.superlabel.ca/api/graphql', { method: 'POST', headers: { 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, body: JSON.stringify({ query: `mutation DriverDeletePictures($id: Int) { driverDeletePictures(id: $id) }`, variables: { "id": 1 }, }), }); const data = await response.json(); console.log(data);

import java.net.http.*; import java.net.URI; HttpClient client = HttpClient.newHttpClient(); String body = "{\"query\":\"mutation DriverDeletePictures($id: Int) {\\n driverDeletePictures(id: $id)\\n}\",\"variables\":{\"id\":1}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.superlabel.ca/api/graphql")) .header("Content-Type", "application/json") .header("Accept", "application/json") .header("Authorization", "Bearer YOUR_TOKEN") .POST(HttpRequest.BodyPublishers.ofString(body)) .build(); HttpResponse<String> response = client.send( request, HttpResponse.BodyHandlers.ofString() ); System.out.println(response.body());

require 'net/http' require 'json' require 'uri' uri = URI.parse('https://api.superlabel.ca/api/graphql') http = Net::HTTP.new(uri.host, uri.port) http.use_ssl = uri.scheme == 'https' request = Net::HTTP::Post.new(uri) request.content_type = 'application/json' request['Accept'] = 'application/json' request['Authorization'] = 'Bearer YOUR_TOKEN' request.body = JSON.dump({ query: 'mutation DriverDeletePictures($id: Int) { driverDeletePictures(id: $id) }', variables: {"id":1} }) response = http.request(request) puts JSON.parse(response.body)

<?php require 'vendor/autoload.php'; $client = new GuzzleHttp\Client(); $response = $client->post('https://api.superlabel.ca/api/graphql', [ 'headers' => [ 'Content-Type' => 'application/json', 'Accept' => 'application/json', 'Authorization' => 'Bearer YOUR_TOKEN', ], 'json' => [ 'query' => 'mutation DriverEndDelivery($routeId: Int, $gps_tracking_id: Int) { driverEndDelivery(routeId: $routeId, gps_tracking_id: $gps_tracking_id) }', 'variables' => json_decode('{"routeId":1,"gps_tracking_id":1}', true), ], ]); $data = json_decode($response->getBody(), true); print_r($data);

import requests response = requests.post( 'https://api.superlabel.ca/api/graphql', headers={ 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, json={ 'query': 'mutation DriverEndDelivery($routeId: Int, $gps_tracking_id: Int) { driverEndDelivery(routeId: $routeId, gps_tracking_id: $gps_tracking_id) }', 'variables': {"routeId":1,"gps_tracking_id":1}, }, ) data = response.json() print(data)

package main import ( "bytes" "encoding/json" "fmt" "io" "net/http" ) func main() { payload, _ := json.Marshal(map[string]interface{}{ "query": `mutation DriverEndDelivery($routeId: Int, $gps_tracking_id: Int) { driverEndDelivery(routeId: $routeId, gps_tracking_id: $gps_tracking_id) }`, "variables": {"routeId":1,"gps_tracking_id":1}, }) req, _ := http.NewRequest("POST", "https://api.superlabel.ca/api/graphql", bytes.NewBuffer(payload)) req.Header.Set("Content-Type", "application/json") req.Header.Set("Accept", "application/json") req.Header.Set("Authorization", "Bearer YOUR_TOKEN") client := &http.Client{} resp, _ := client.Do(req) defer resp.Body.Close() body, _ := io.ReadAll(resp.Body) fmt.Println(string(body)) }

const response = await fetch('https://api.superlabel.ca/api/graphql', { method: 'POST', headers: { 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, body: JSON.stringify({ query: `mutation DriverEndDelivery($routeId: Int, $gps_tracking_id: Int) { driverEndDelivery(routeId: $routeId, gps_tracking_id: $gps_tracking_id) }`, variables: { "routeId": 1, "gps_tracking_id": 1 }, }), }); const data = await response.json(); console.log(data);

import java.net.http.*; import java.net.URI; HttpClient client = HttpClient.newHttpClient(); String body = "{\"query\":\"mutation DriverEndDelivery($routeId: Int, $gps_tracking_id: Int) {\\n driverEndDelivery(routeId: $routeId, gps_tracking_id: $gps_tracking_id)\\n}\",\"variables\":{\"routeId\":1,\"gps_tracking_id\":1}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.superlabel.ca/api/graphql")) .header("Content-Type", "application/json") .header("Accept", "application/json") .header("Authorization", "Bearer YOUR_TOKEN") .POST(HttpRequest.BodyPublishers.ofString(body)) .build(); HttpResponse<String> response = client.send( request, HttpResponse.BodyHandlers.ofString() ); System.out.println(response.body());

require 'net/http' require 'json' require 'uri' uri = URI.parse('https://api.superlabel.ca/api/graphql') http = Net::HTTP.new(uri.host, uri.port) http.use_ssl = uri.scheme == 'https' request = Net::HTTP::Post.new(uri) request.content_type = 'application/json' request['Accept'] = 'application/json' request['Authorization'] = 'Bearer YOUR_TOKEN' request.body = JSON.dump({ query: 'mutation DriverEndDelivery($routeId: Int, $gps_tracking_id: Int) { driverEndDelivery(routeId: $routeId, gps_tracking_id: $gps_tracking_id) }', variables: {"routeId":1,"gps_tracking_id":1} }) response = http.request(request) puts JSON.parse(response.body)

<?php require 'vendor/autoload.php'; $client = new GuzzleHttp\Client(); $response = $client->post('https://api.superlabel.ca/api/graphql', [ 'headers' => [ 'Content-Type' => 'application/json', 'Accept' => 'application/json', 'Authorization' => 'Bearer YOUR_TOKEN', ], 'json' => [ 'query' => 'mutation DriverKioskReceivePackage($route_id: Int!, $order_id: Int!, $scan_code: String!) { driverKioskReceivePackage(route_id: $route_id, order_id: $order_id, scan_code: $scan_code) }', 'variables' => json_decode('{"route_id":1,"order_id":1,"scan_code":"example"}', true), ], ]); $data = json_decode($response->getBody(), true); print_r($data);

import requests response = requests.post( 'https://api.superlabel.ca/api/graphql', headers={ 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, json={ 'query': 'mutation DriverKioskReceivePackage($route_id: Int!, $order_id: Int!, $scan_code: String!) { driverKioskReceivePackage(route_id: $route_id, order_id: $order_id, scan_code: $scan_code) }', 'variables': {"route_id":1,"order_id":1,"scan_code":"example"}, }, ) data = response.json() print(data)

package main import ( "bytes" "encoding/json" "fmt" "io" "net/http" ) func main() { payload, _ := json.Marshal(map[string]interface{}{ "query": `mutation DriverKioskReceivePackage($route_id: Int!, $order_id: Int!, $scan_code: String!) { driverKioskReceivePackage(route_id: $route_id, order_id: $order_id, scan_code: $scan_code) }`, "variables": {"route_id":1,"order_id":1,"scan_code":"example"}, }) req, _ := http.NewRequest("POST", "https://api.superlabel.ca/api/graphql", bytes.NewBuffer(payload)) req.Header.Set("Content-Type", "application/json") req.Header.Set("Accept", "application/json") req.Header.Set("Authorization", "Bearer YOUR_TOKEN") client := &http.Client{} resp, _ := client.Do(req) defer resp.Body.Close() body, _ := io.ReadAll(resp.Body) fmt.Println(string(body)) }

const response = await fetch('https://api.superlabel.ca/api/graphql', { method: 'POST', headers: { 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, body: JSON.stringify({ query: `mutation DriverKioskReceivePackage($route_id: Int!, $order_id: Int!, $scan_code: String!) { driverKioskReceivePackage(route_id: $route_id, order_id: $order_id, scan_code: $scan_code) }`, variables: { "route_id": 1, "order_id": 1, "scan_code": "example" }, }), }); const data = await response.json(); console.log(data);

import java.net.http.*; import java.net.URI; HttpClient client = HttpClient.newHttpClient(); String body = "{\"query\":\"mutation DriverKioskReceivePackage($route_id: Int!, $order_id: Int!, $scan_code: String!) {\\n driverKioskReceivePackage(route_id: $route_id, order_id: $order_id, scan_code: $scan_code)\\n}\",\"variables\":{\"route_id\":1,\"order_id\":1,\"scan_code\":\"example\"}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.superlabel.ca/api/graphql")) .header("Content-Type", "application/json") .header("Accept", "application/json") .header("Authorization", "Bearer YOUR_TOKEN") .POST(HttpRequest.BodyPublishers.ofString(body)) .build(); HttpResponse<String> response = client.send( request, HttpResponse.BodyHandlers.ofString() ); System.out.println(response.body());

require 'net/http' require 'json' require 'uri' uri = URI.parse('https://api.superlabel.ca/api/graphql') http = Net::HTTP.new(uri.host, uri.port) http.use_ssl = uri.scheme == 'https' request = Net::HTTP::Post.new(uri) request.content_type = 'application/json' request['Accept'] = 'application/json' request['Authorization'] = 'Bearer YOUR_TOKEN' request.body = JSON.dump({ query: 'mutation DriverKioskReceivePackage($route_id: Int!, $order_id: Int!, $scan_code: String!) { driverKioskReceivePackage(route_id: $route_id, order_id: $order_id, scan_code: $scan_code) }', variables: {"route_id":1,"order_id":1,"scan_code":"example"} }) response = http.request(request) puts JSON.parse(response.body)

<?php require 'vendor/autoload.php'; $client = new GuzzleHttp\Client(); $response = $client->post('https://api.superlabel.ca/api/graphql', [ 'headers' => [ 'Content-Type' => 'application/json', 'Accept' => 'application/json', 'Authorization' => 'Bearer YOUR_TOKEN', ], 'json' => [ 'query' => 'mutation DriverOptimizeRoute($async: Boolean, $routeId: Int, $driverAddresses: Json) { driverOptimizeRoute(async: $async, routeId: $routeId, driverAddresses: $driverAddresses) }', 'variables' => json_decode('{"async":true,"routeId":1,"driverAddresses":{"key":"value"}}', true), ], ]); $data = json_decode($response->getBody(), true); print_r($data);

import requests response = requests.post( 'https://api.superlabel.ca/api/graphql', headers={ 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, json={ 'query': 'mutation DriverOptimizeRoute($async: Boolean, $routeId: Int, $driverAddresses: Json) { driverOptimizeRoute(async: $async, routeId: $routeId, driverAddresses: $driverAddresses) }', 'variables': {"async":true,"routeId":1,"driverAddresses":{"key":"value"}}, }, ) data = response.json() print(data)

package main import ( "bytes" "encoding/json" "fmt" "io" "net/http" ) func main() { payload, _ := json.Marshal(map[string]interface{}{ "query": `mutation DriverOptimizeRoute($async: Boolean, $routeId: Int, $driverAddresses: Json) { driverOptimizeRoute(async: $async, routeId: $routeId, driverAddresses: $driverAddresses) }`, "variables": {"async":true,"routeId":1,"driverAddresses":{"key":"value"}}, }) req, _ := http.NewRequest("POST", "https://api.superlabel.ca/api/graphql", bytes.NewBuffer(payload)) req.Header.Set("Content-Type", "application/json") req.Header.Set("Accept", "application/json") req.Header.Set("Authorization", "Bearer YOUR_TOKEN") client := &http.Client{} resp, _ := client.Do(req) defer resp.Body.Close() body, _ := io.ReadAll(resp.Body) fmt.Println(string(body)) }

const response = await fetch('https://api.superlabel.ca/api/graphql', { method: 'POST', headers: { 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, body: JSON.stringify({ query: `mutation DriverOptimizeRoute($async: Boolean, $routeId: Int, $driverAddresses: Json) { driverOptimizeRoute(async: $async, routeId: $routeId, driverAddresses: $driverAddresses) }`, variables: { "async": true, "routeId": 1, "driverAddresses": { "key": "value" } }, }), }); const data = await response.json(); console.log(data);

import java.net.http.*; import java.net.URI; HttpClient client = HttpClient.newHttpClient(); String body = "{\"query\":\"mutation DriverOptimizeRoute($async: Boolean, $routeId: Int, $driverAddresses: Json) {\\n driverOptimizeRoute(async: $async, routeId: $routeId, driverAddresses: $driverAddresses)\\n}\",\"variables\":{\"async\":true,\"routeId\":1,\"driverAddresses\":{\"key\":\"value\"}}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.superlabel.ca/api/graphql")) .header("Content-Type", "application/json") .header("Accept", "application/json") .header("Authorization", "Bearer YOUR_TOKEN") .POST(HttpRequest.BodyPublishers.ofString(body)) .build(); HttpResponse<String> response = client.send( request, HttpResponse.BodyHandlers.ofString() ); System.out.println(response.body());

require 'net/http' require 'json' require 'uri' uri = URI.parse('https://api.superlabel.ca/api/graphql') http = Net::HTTP.new(uri.host, uri.port) http.use_ssl = uri.scheme == 'https' request = Net::HTTP::Post.new(uri) request.content_type = 'application/json' request['Accept'] = 'application/json' request['Authorization'] = 'Bearer YOUR_TOKEN' request.body = JSON.dump({ query: 'mutation DriverOptimizeRoute($async: Boolean, $routeId: Int, $driverAddresses: Json) { driverOptimizeRoute(async: $async, routeId: $routeId, driverAddresses: $driverAddresses) }', variables: {"async":true,"routeId":1,"driverAddresses":{"key":"value"}} }) response = http.request(request) puts JSON.parse(response.body)

<?php require 'vendor/autoload.php'; $client = new GuzzleHttp\Client(); $response = $client->post('https://api.superlabel.ca/api/graphql', [ 'headers' => [ 'Content-Type' => 'application/json', 'Accept' => 'application/json', 'Authorization' => 'Bearer YOUR_TOKEN', ], 'json' => [ 'query' => 'mutation DriverOrdersNotesCreate($orderId: Int, $notes: String) { driverOrdersNotesCreate(orderId: $orderId, notes: $notes) }', 'variables' => json_decode('{"orderId":1,"notes":"example"}', true), ], ]); $data = json_decode($response->getBody(), true); print_r($data);

import requests response = requests.post( 'https://api.superlabel.ca/api/graphql', headers={ 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, json={ 'query': 'mutation DriverOrdersNotesCreate($orderId: Int, $notes: String) { driverOrdersNotesCreate(orderId: $orderId, notes: $notes) }', 'variables': {"orderId":1,"notes":"example"}, }, ) data = response.json() print(data)

package main import ( "bytes" "encoding/json" "fmt" "io" "net/http" ) func main() { payload, _ := json.Marshal(map[string]interface{}{ "query": `mutation DriverOrdersNotesCreate($orderId: Int, $notes: String) { driverOrdersNotesCreate(orderId: $orderId, notes: $notes) }`, "variables": {"orderId":1,"notes":"example"}, }) req, _ := http.NewRequest("POST", "https://api.superlabel.ca/api/graphql", bytes.NewBuffer(payload)) req.Header.Set("Content-Type", "application/json") req.Header.Set("Accept", "application/json") req.Header.Set("Authorization", "Bearer YOUR_TOKEN") client := &http.Client{} resp, _ := client.Do(req) defer resp.Body.Close() body, _ := io.ReadAll(resp.Body) fmt.Println(string(body)) }

const response = await fetch('https://api.superlabel.ca/api/graphql', { method: 'POST', headers: { 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, body: JSON.stringify({ query: `mutation DriverOrdersNotesCreate($orderId: Int, $notes: String) { driverOrdersNotesCreate(orderId: $orderId, notes: $notes) }`, variables: { "orderId": 1, "notes": "example" }, }), }); const data = await response.json(); console.log(data);

import java.net.http.*; import java.net.URI; HttpClient client = HttpClient.newHttpClient(); String body = "{\"query\":\"mutation DriverOrdersNotesCreate($orderId: Int, $notes: String) {\\n driverOrdersNotesCreate(orderId: $orderId, notes: $notes)\\n}\",\"variables\":{\"orderId\":1,\"notes\":\"example\"}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.superlabel.ca/api/graphql")) .header("Content-Type", "application/json") .header("Accept", "application/json") .header("Authorization", "Bearer YOUR_TOKEN") .POST(HttpRequest.BodyPublishers.ofString(body)) .build(); HttpResponse<String> response = client.send( request, HttpResponse.BodyHandlers.ofString() ); System.out.println(response.body());

require 'net/http' require 'json' require 'uri' uri = URI.parse('https://api.superlabel.ca/api/graphql') http = Net::HTTP.new(uri.host, uri.port) http.use_ssl = uri.scheme == 'https' request = Net::HTTP::Post.new(uri) request.content_type = 'application/json' request['Accept'] = 'application/json' request['Authorization'] = 'Bearer YOUR_TOKEN' request.body = JSON.dump({ query: 'mutation DriverOrdersNotesCreate($orderId: Int, $notes: String) { driverOrdersNotesCreate(orderId: $orderId, notes: $notes) }', variables: {"orderId":1,"notes":"example"} }) response = http.request(request) puts JSON.parse(response.body)

<?php require 'vendor/autoload.php'; $client = new GuzzleHttp\Client(); $response = $client->post('https://api.superlabel.ca/api/graphql', [ 'headers' => [ 'Content-Type' => 'application/json', 'Accept' => 'application/json', 'Authorization' => 'Bearer YOUR_TOKEN', ], 'json' => [ 'query' => 'mutation DriverOrdersStatus($orderId: Int, $packageIds: [String], $status: String, $return_reason_id: Int, $gps_tracking_id: Int, $routeId: Int) { driverOrdersStatus(orderId: $orderId, packageIds: $packageIds, status: $status, return_reason_id: $return_reason_id, gps_tracking_id: $gps_tracking_id, routeId: $routeId) }', 'variables' => json_decode('{"orderId":1,"packageIds":["example"],"status":"example","return_reason_id":1,"gps_tracking_id":1,"routeId":1}', true), ], ]); $data = json_decode($response->getBody(), true); print_r($data);

import requests response = requests.post( 'https://api.superlabel.ca/api/graphql', headers={ 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, json={ 'query': 'mutation DriverOrdersStatus($orderId: Int, $packageIds: [String], $status: String, $return_reason_id: Int, $gps_tracking_id: Int, $routeId: Int) { driverOrdersStatus(orderId: $orderId, packageIds: $packageIds, status: $status, return_reason_id: $return_reason_id, gps_tracking_id: $gps_tracking_id, routeId: $routeId) }', 'variables': {"orderId":1,"packageIds":["example"],"status":"example","return_reason_id":1,"gps_tracking_id":1,"routeId":1}, }, ) data = response.json() print(data)

package main import ( "bytes" "encoding/json" "fmt" "io" "net/http" ) func main() { payload, _ := json.Marshal(map[string]interface{}{ "query": `mutation DriverOrdersStatus($orderId: Int, $packageIds: [String], $status: String, $return_reason_id: Int, $gps_tracking_id: Int, $routeId: Int) { driverOrdersStatus(orderId: $orderId, packageIds: $packageIds, status: $status, return_reason_id: $return_reason_id, gps_tracking_id: $gps_tracking_id, routeId: $routeId) }`, "variables": {"orderId":1,"packageIds":["example"],"status":"example","return_reason_id":1,"gps_tracking_id":1,"routeId":1}, }) req, _ := http.NewRequest("POST", "https://api.superlabel.ca/api/graphql", bytes.NewBuffer(payload)) req.Header.Set("Content-Type", "application/json") req.Header.Set("Accept", "application/json") req.Header.Set("Authorization", "Bearer YOUR_TOKEN") client := &http.Client{} resp, _ := client.Do(req) defer resp.Body.Close() body, _ := io.ReadAll(resp.Body) fmt.Println(string(body)) }

const response = await fetch('https://api.superlabel.ca/api/graphql', { method: 'POST', headers: { 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, body: JSON.stringify({ query: `mutation DriverOrdersStatus($orderId: Int, $packageIds: [String], $status: String, $return_reason_id: Int, $gps_tracking_id: Int, $routeId: Int) { driverOrdersStatus(orderId: $orderId, packageIds: $packageIds, status: $status, return_reason_id: $return_reason_id, gps_tracking_id: $gps_tracking_id, routeId: $routeId) }`, variables: { "orderId": 1, "packageIds": [ "example" ], "status": "example", "return_reason_id": 1, "gps_tracking_id": 1, "routeId": 1 }, }), }); const data = await response.json(); console.log(data);

import java.net.http.*; import java.net.URI; HttpClient client = HttpClient.newHttpClient(); String body = "{\"query\":\"mutation DriverOrdersStatus($orderId: Int, $packageIds: [String], $status: String, $return_reason_id: Int, $gps_tracking_id: Int, $routeId: Int) {\\n driverOrdersStatus(orderId: $orderId, packageIds: $packageIds, status: $status, return_reason_id: $return_reason_id, gps_tracking_id: $gps_tracking_id, routeId: $routeId)\\n}\",\"variables\":{\"orderId\":1,\"packageIds\":[\"example\"],\"status\":\"example\",\"return_reason_id\":1,\"gps_tracking_id\":1,\"routeId\":1}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.superlabel.ca/api/graphql")) .header("Content-Type", "application/json") .header("Accept", "application/json") .header("Authorization", "Bearer YOUR_TOKEN") .POST(HttpRequest.BodyPublishers.ofString(body)) .build(); HttpResponse<String> response = client.send( request, HttpResponse.BodyHandlers.ofString() ); System.out.println(response.body());

require 'net/http' require 'json' require 'uri' uri = URI.parse('https://api.superlabel.ca/api/graphql') http = Net::HTTP.new(uri.host, uri.port) http.use_ssl = uri.scheme == 'https' request = Net::HTTP::Post.new(uri) request.content_type = 'application/json' request['Accept'] = 'application/json' request['Authorization'] = 'Bearer YOUR_TOKEN' request.body = JSON.dump({ query: 'mutation DriverOrdersStatus($orderId: Int, $packageIds: [String], $status: String, $return_reason_id: Int, $gps_tracking_id: Int, $routeId: Int) { driverOrdersStatus(orderId: $orderId, packageIds: $packageIds, status: $status, return_reason_id: $return_reason_id, gps_tracking_id: $gps_tracking_id, routeId: $routeId) }', variables: {"orderId":1,"packageIds":["example"],"status":"example","return_reason_id":1,"gps_tracking_id":1,"routeId":1} }) response = http.request(request) puts JSON.parse(response.body)

<?php require 'vendor/autoload.php'; $client = new GuzzleHttp\Client(); $response = $client->post('https://api.superlabel.ca/api/graphql', [ 'headers' => [ 'Content-Type' => 'application/json', 'Accept' => 'application/json', 'Authorization' => 'Bearer YOUR_TOKEN', ], 'json' => [ 'query' => 'mutation DriverProfile($name: String, $alias: String, $email: String, $password: String, $telephone: String, $language: String, $status: Int, $capacity: Int, $vehicle_type: Int, $fuel_type: Int, $territory_id: Int, $start_location_id: Int, $end_location_id: Int, $skills: [Int]) { driverProfile(name: $name, alias: $alias, email: $email, password: $password, telephone: $telephone, language: $language, status: $status, capacity: $capacity, vehicle_type: $vehicle_type, fuel_type: $fuel_type, territory_id: $territory_id, start_location_id: $start_location_id, end_location_id: $end_location_id, skills: $skills) }', 'variables' => json_decode('{"name":"example","alias":"example","email":"user@example.com","password":"example","telephone":"+14165551234","language":"example","status":1,"capacity":1,"vehicle_type":1,"fuel_type":1,"territory_id":1,"start_location_id":1,"end_location_id":1,"skills":[1]}', true), ], ]); $data = json_decode($response->getBody(), true); print_r($data);

import requests response = requests.post( 'https://api.superlabel.ca/api/graphql', headers={ 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, json={ 'query': 'mutation DriverProfile($name: String, $alias: String, $email: String, $password: String, $telephone: String, $language: String, $status: Int, $capacity: Int, $vehicle_type: Int, $fuel_type: Int, $territory_id: Int, $start_location_id: Int, $end_location_id: Int, $skills: [Int]) { driverProfile(name: $name, alias: $alias, email: $email, password: $password, telephone: $telephone, language: $language, status: $status, capacity: $capacity, vehicle_type: $vehicle_type, fuel_type: $fuel_type, territory_id: $territory_id, start_location_id: $start_location_id, end_location_id: $end_location_id, skills: $skills) }', 'variables': {"name":"example","alias":"example","email":"user@example.com","password":"example","telephone":"+14165551234","language":"example","status":1,"capacity":1,"vehicle_type":1,"fuel_type":1,"territory_id":1,"start_location_id":1,"end_location_id":1,"skills":[1]}, }, ) data = response.json() print(data)

package main import ( "bytes" "encoding/json" "fmt" "io" "net/http" ) func main() { payload, _ := json.Marshal(map[string]interface{}{ "query": `mutation DriverProfile($name: String, $alias: String, $email: String, $password: String, $telephone: String, $language: String, $status: Int, $capacity: Int, $vehicle_type: Int, $fuel_type: Int, $territory_id: Int, $start_location_id: Int, $end_location_id: Int, $skills: [Int]) { driverProfile(name: $name, alias: $alias, email: $email, password: $password, telephone: $telephone, language: $language, status: $status, capacity: $capacity, vehicle_type: $vehicle_type, fuel_type: $fuel_type, territory_id: $territory_id, start_location_id: $start_location_id, end_location_id: $end_location_id, skills: $skills) }`, "variables": {"name":"example","alias":"example","email":"user@example.com","password":"example","telephone":"+14165551234","language":"example","status":1,"capacity":1,"vehicle_type":1,"fuel_type":1,"territory_id":1,"start_location_id":1,"end_location_id":1,"skills":[1]}, }) req, _ := http.NewRequest("POST", "https://api.superlabel.ca/api/graphql", bytes.NewBuffer(payload)) req.Header.Set("Content-Type", "application/json") req.Header.Set("Accept", "application/json") req.Header.Set("Authorization", "Bearer YOUR_TOKEN") client := &http.Client{} resp, _ := client.Do(req) defer resp.Body.Close() body, _ := io.ReadAll(resp.Body) fmt.Println(string(body)) }

const response = await fetch('https://api.superlabel.ca/api/graphql', { method: 'POST', headers: { 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, body: JSON.stringify({ query: `mutation DriverProfile($name: String, $alias: String, $email: String, $password: String, $telephone: String, $language: String, $status: Int, $capacity: Int, $vehicle_type: Int, $fuel_type: Int, $territory_id: Int, $start_location_id: Int, $end_location_id: Int, $skills: [Int]) { driverProfile(name: $name, alias: $alias, email: $email, password: $password, telephone: $telephone, language: $language, status: $status, capacity: $capacity, vehicle_type: $vehicle_type, fuel_type: $fuel_type, territory_id: $territory_id, start_location_id: $start_location_id, end_location_id: $end_location_id, skills: $skills) }`, variables: { "name": "example", "alias": "example", "email": "user@example.com", "password": "example", "telephone": "+14165551234", "language": "example", "status": 1, "capacity": 1, "vehicle_type": 1, "fuel_type": 1, "territory_id": 1, "start_location_id": 1, "end_location_id": 1, "skills": [ 1 ] }, }), }); const data = await response.json(); console.log(data);

import java.net.http.*; import java.net.URI; HttpClient client = HttpClient.newHttpClient(); String body = "{\"query\":\"mutation DriverProfile($name: String, $alias: String, $email: String, $password: String, $telephone: String, $language: String, $status: Int, $capacity: Int, $vehicle_type: Int, $fuel_type: Int, $territory_id: Int, $start_location_id: Int, $end_location_id: Int, $skills: [Int]) {\\n driverProfile(name: $name, alias: $alias, email: $email, password: $password, telephone: $telephone, language: $language, status: $status, capacity: $capacity, vehicle_type: $vehicle_type, fuel_type: $fuel_type, territory_id: $territory_id, start_location_id: $start_location_id, end_location_id: $end_location_id, skills: $skills)\\n}\",\"variables\":{\"name\":\"example\",\"alias\":\"example\",\"email\":\"user@example.com\",\"password\":\"example\",\"telephone\":\"+14165551234\",\"language\":\"example\",\"status\":1,\"capacity\":1,\"vehicle_type\":1,\"fuel_type\":1,\"territory_id\":1,\"start_location_id\":1,\"end_location_id\":1,\"skills\":[1]}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.superlabel.ca/api/graphql")) .header("Content-Type", "application/json") .header("Accept", "application/json") .header("Authorization", "Bearer YOUR_TOKEN") .POST(HttpRequest.BodyPublishers.ofString(body)) .build(); HttpResponse<String> response = client.send( request, HttpResponse.BodyHandlers.ofString() ); System.out.println(response.body());

require 'net/http' require 'json' require 'uri' uri = URI.parse('https://api.superlabel.ca/api/graphql') http = Net::HTTP.new(uri.host, uri.port) http.use_ssl = uri.scheme == 'https' request = Net::HTTP::Post.new(uri) request.content_type = 'application/json' request['Accept'] = 'application/json' request['Authorization'] = 'Bearer YOUR_TOKEN' request.body = JSON.dump({ query: 'mutation DriverProfile($name: String, $alias: String, $email: String, $password: String, $telephone: String, $language: String, $status: Int, $capacity: Int, $vehicle_type: Int, $fuel_type: Int, $territory_id: Int, $start_location_id: Int, $end_location_id: Int, $skills: [Int]) { driverProfile(name: $name, alias: $alias, email: $email, password: $password, telephone: $telephone, language: $language, status: $status, capacity: $capacity, vehicle_type: $vehicle_type, fuel_type: $fuel_type, territory_id: $territory_id, start_location_id: $start_location_id, end_location_id: $end_location_id, skills: $skills) }', variables: {"name":"example","alias":"example","email":"user@example.com","password":"example","telephone":"+14165551234","language":"example","status":1,"capacity":1,"vehicle_type":1,"fuel_type":1,"territory_id":1,"start_location_id":1,"end_location_id":1,"skills":[1]} }) response = http.request(request) puts JSON.parse(response.body)

<?php require 'vendor/autoload.php'; $client = new GuzzleHttp\Client(); $response = $client->post('https://api.superlabel.ca/api/graphql', [ 'headers' => [ 'Content-Type' => 'application/json', 'Accept' => 'application/json', ], 'json' => [ 'query' => 'mutation DriverRegister($business_id: Int, $alias: String, $name: String, $password: String, $email: String, $telephone: String, $address: String, $address_2: String, $city: String, $province: String, $country: String, $postcode: String, $language: String, $capacity: Int, $vehicle_type: Int, $fuel_type: Int, $territory_id: Int, $start_location_id: Int, $end_location_id: Int) { driverRegister(business_id: $business_id, alias: $alias, name: $name, password: $password, email: $email, telephone: $telephone, address: $address, address_2: $address_2, city: $city, province: $province, country: $country, postcode: $postcode, language: $language, capacity: $capacity, vehicle_type: $vehicle_type, fuel_type: $fuel_type, territory_id: $territory_id, start_location_id: $start_location_id, end_location_id: $end_location_id) }', 'variables' => json_decode('{"business_id":1,"alias":"example","name":"example","password":"example","email":"user@example.com","telephone":"+14165551234","address":"example","address_2":"example","city":"Toronto","province":"ON","country":"CA","postcode":"M5V 2T6","language":"example","capacity":1,"vehicle_type":1,"fuel_type":1,"territory_id":1,"start_location_id":1,"end_location_id":1}', true), ], ]); $data = json_decode($response->getBody(), true); print_r($data);

import requests response = requests.post( 'https://api.superlabel.ca/api/graphql', headers={ 'Content-Type': 'application/json', 'Accept': 'application/json', }, json={ 'query': 'mutation DriverRegister($business_id: Int, $alias: String, $name: String, $password: String, $email: String, $telephone: String, $address: String, $address_2: String, $city: String, $province: String, $country: String, $postcode: String, $language: String, $capacity: Int, $vehicle_type: Int, $fuel_type: Int, $territory_id: Int, $start_location_id: Int, $end_location_id: Int) { driverRegister(business_id: $business_id, alias: $alias, name: $name, password: $password, email: $email, telephone: $telephone, address: $address, address_2: $address_2, city: $city, province: $province, country: $country, postcode: $postcode, language: $language, capacity: $capacity, vehicle_type: $vehicle_type, fuel_type: $fuel_type, territory_id: $territory_id, start_location_id: $start_location_id, end_location_id: $end_location_id) }', 'variables': {"business_id":1,"alias":"example","name":"example","password":"example","email":"user@example.com","telephone":"+14165551234","address":"example","address_2":"example","city":"Toronto","province":"ON","country":"CA","postcode":"M5V 2T6","language":"example","capacity":1,"vehicle_type":1,"fuel_type":1,"territory_id":1,"start_location_id":1,"end_location_id":1}, }, ) data = response.json() print(data)

package main import ( "bytes" "encoding/json" "fmt" "io" "net/http" ) func main() { payload, _ := json.Marshal(map[string]interface{}{ "query": `mutation DriverRegister($business_id: Int, $alias: String, $name: String, $password: String, $email: String, $telephone: String, $address: String, $address_2: String, $city: String, $province: String, $country: String, $postcode: String, $language: String, $capacity: Int, $vehicle_type: Int, $fuel_type: Int, $territory_id: Int, $start_location_id: Int, $end_location_id: Int) { driverRegister(business_id: $business_id, alias: $alias, name: $name, password: $password, email: $email, telephone: $telephone, address: $address, address_2: $address_2, city: $city, province: $province, country: $country, postcode: $postcode, language: $language, capacity: $capacity, vehicle_type: $vehicle_type, fuel_type: $fuel_type, territory_id: $territory_id, start_location_id: $start_location_id, end_location_id: $end_location_id) }`, "variables": {"business_id":1,"alias":"example","name":"example","password":"example","email":"user@example.com","telephone":"+14165551234","address":"example","address_2":"example","city":"Toronto","province":"ON","country":"CA","postcode":"M5V 2T6","language":"example","capacity":1,"vehicle_type":1,"fuel_type":1,"territory_id":1,"start_location_id":1,"end_location_id":1}, }) req, _ := http.NewRequest("POST", "https://api.superlabel.ca/api/graphql", bytes.NewBuffer(payload)) req.Header.Set("Content-Type", "application/json") req.Header.Set("Accept", "application/json") client := &http.Client{} resp, _ := client.Do(req) defer resp.Body.Close() body, _ := io.ReadAll(resp.Body) fmt.Println(string(body)) }

const response = await fetch('https://api.superlabel.ca/api/graphql', { method: 'POST', headers: { 'Content-Type': 'application/json', 'Accept': 'application/json', }, body: JSON.stringify({ query: `mutation DriverRegister($business_id: Int, $alias: String, $name: String, $password: String, $email: String, $telephone: String, $address: String, $address_2: String, $city: String, $province: String, $country: String, $postcode: String, $language: String, $capacity: Int, $vehicle_type: Int, $fuel_type: Int, $territory_id: Int, $start_location_id: Int, $end_location_id: Int) { driverRegister(business_id: $business_id, alias: $alias, name: $name, password: $password, email: $email, telephone: $telephone, address: $address, address_2: $address_2, city: $city, province: $province, country: $country, postcode: $postcode, language: $language, capacity: $capacity, vehicle_type: $vehicle_type, fuel_type: $fuel_type, territory_id: $territory_id, start_location_id: $start_location_id, end_location_id: $end_location_id) }`, variables: { "business_id": 1, "alias": "example", "name": "example", "password": "example", "email": "user@example.com", "telephone": "+14165551234", "address": "example", "address_2": "example", "city": "Toronto", "province": "ON", "country": "CA", "postcode": "M5V 2T6", "language": "example", "capacity": 1, "vehicle_type": 1, "fuel_type": 1, "territory_id": 1, "start_location_id": 1, "end_location_id": 1 }, }), }); const data = await response.json(); console.log(data);

import java.net.http.*; import java.net.URI; HttpClient client = HttpClient.newHttpClient(); String body = "{\"query\":\"mutation DriverRegister($business_id: Int, $alias: String, $name: String, $password: String, $email: String, $telephone: String, $address: String, $address_2: String, $city: String, $province: String, $country: String, $postcode: String, $language: String, $capacity: Int, $vehicle_type: Int, $fuel_type: Int, $territory_id: Int, $start_location_id: Int, $end_location_id: Int) {\\n driverRegister(business_id: $business_id, alias: $alias, name: $name, password: $password, email: $email, telephone: $telephone, address: $address, address_2: $address_2, city: $city, province: $province, country: $country, postcode: $postcode, language: $language, capacity: $capacity, vehicle_type: $vehicle_type, fuel_type: $fuel_type, territory_id: $territory_id, start_location_id: $start_location_id, end_location_id: $end_location_id)\\n}\",\"variables\":{\"business_id\":1,\"alias\":\"example\",\"name\":\"example\",\"password\":\"example\",\"email\":\"user@example.com\",\"telephone\":\"+14165551234\",\"address\":\"example\",\"address_2\":\"example\",\"city\":\"Toronto\",\"province\":\"ON\",\"country\":\"CA\",\"postcode\":\"M5V 2T6\",\"language\":\"example\",\"capacity\":1,\"vehicle_type\":1,\"fuel_type\":1,\"territory_id\":1,\"start_location_id\":1,\"end_location_id\":1}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.superlabel.ca/api/graphql")) .header("Content-Type", "application/json") .header("Accept", "application/json") .POST(HttpRequest.BodyPublishers.ofString(body)) .build(); HttpResponse<String> response = client.send( request, HttpResponse.BodyHandlers.ofString() ); System.out.println(response.body());

require 'net/http' require 'json' require 'uri' uri = URI.parse('https://api.superlabel.ca/api/graphql') http = Net::HTTP.new(uri.host, uri.port) http.use_ssl = uri.scheme == 'https' request = Net::HTTP::Post.new(uri) request.content_type = 'application/json' request['Accept'] = 'application/json' request.body = JSON.dump({ query: 'mutation DriverRegister($business_id: Int, $alias: String, $name: String, $password: String, $email: String, $telephone: String, $address: String, $address_2: String, $city: String, $province: String, $country: String, $postcode: String, $language: String, $capacity: Int, $vehicle_type: Int, $fuel_type: Int, $territory_id: Int, $start_location_id: Int, $end_location_id: Int) { driverRegister(business_id: $business_id, alias: $alias, name: $name, password: $password, email: $email, telephone: $telephone, address: $address, address_2: $address_2, city: $city, province: $province, country: $country, postcode: $postcode, language: $language, capacity: $capacity, vehicle_type: $vehicle_type, fuel_type: $fuel_type, territory_id: $territory_id, start_location_id: $start_location_id, end_location_id: $end_location_id) }', variables: {"business_id":1,"alias":"example","name":"example","password":"example","email":"user@example.com","telephone":"+14165551234","address":"example","address_2":"example","city":"Toronto","province":"ON","country":"CA","postcode":"M5V 2T6","language":"example","capacity":1,"vehicle_type":1,"fuel_type":1,"territory_id":1,"start_location_id":1,"end_location_id":1} }) response = http.request(request) puts JSON.parse(response.body)

<?php require 'vendor/autoload.php'; $client = new GuzzleHttp\Client(); $response = $client->post('https://api.superlabel.ca/api/graphql', [ 'headers' => [ 'Content-Type' => 'application/json', 'Accept' => 'application/json', 'Authorization' => 'Bearer YOUR_TOKEN', ], 'json' => [ 'query' => 'mutation DriverRoutesAddOrder($routeId: Int, $ref: String, $optimize: Int) { driverRoutesAddOrder(routeId: $routeId, ref: $ref, optimize: $optimize) }', 'variables' => json_decode('{"routeId":1,"ref":"example","optimize":1}', true), ], ]); $data = json_decode($response->getBody(), true); print_r($data);

import requests response = requests.post( 'https://api.superlabel.ca/api/graphql', headers={ 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, json={ 'query': 'mutation DriverRoutesAddOrder($routeId: Int, $ref: String, $optimize: Int) { driverRoutesAddOrder(routeId: $routeId, ref: $ref, optimize: $optimize) }', 'variables': {"routeId":1,"ref":"example","optimize":1}, }, ) data = response.json() print(data)

package main import ( "bytes" "encoding/json" "fmt" "io" "net/http" ) func main() { payload, _ := json.Marshal(map[string]interface{}{ "query": `mutation DriverRoutesAddOrder($routeId: Int, $ref: String, $optimize: Int) { driverRoutesAddOrder(routeId: $routeId, ref: $ref, optimize: $optimize) }`, "variables": {"routeId":1,"ref":"example","optimize":1}, }) req, _ := http.NewRequest("POST", "https://api.superlabel.ca/api/graphql", bytes.NewBuffer(payload)) req.Header.Set("Content-Type", "application/json") req.Header.Set("Accept", "application/json") req.Header.Set("Authorization", "Bearer YOUR_TOKEN") client := &http.Client{} resp, _ := client.Do(req) defer resp.Body.Close() body, _ := io.ReadAll(resp.Body) fmt.Println(string(body)) }

const response = await fetch('https://api.superlabel.ca/api/graphql', { method: 'POST', headers: { 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, body: JSON.stringify({ query: `mutation DriverRoutesAddOrder($routeId: Int, $ref: String, $optimize: Int) { driverRoutesAddOrder(routeId: $routeId, ref: $ref, optimize: $optimize) }`, variables: { "routeId": 1, "ref": "example", "optimize": 1 }, }), }); const data = await response.json(); console.log(data);

import java.net.http.*; import java.net.URI; HttpClient client = HttpClient.newHttpClient(); String body = "{\"query\":\"mutation DriverRoutesAddOrder($routeId: Int, $ref: String, $optimize: Int) {\\n driverRoutesAddOrder(routeId: $routeId, ref: $ref, optimize: $optimize)\\n}\",\"variables\":{\"routeId\":1,\"ref\":\"example\",\"optimize\":1}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.superlabel.ca/api/graphql")) .header("Content-Type", "application/json") .header("Accept", "application/json") .header("Authorization", "Bearer YOUR_TOKEN") .POST(HttpRequest.BodyPublishers.ofString(body)) .build(); HttpResponse<String> response = client.send( request, HttpResponse.BodyHandlers.ofString() ); System.out.println(response.body());

require 'net/http' require 'json' require 'uri' uri = URI.parse('https://api.superlabel.ca/api/graphql') http = Net::HTTP.new(uri.host, uri.port) http.use_ssl = uri.scheme == 'https' request = Net::HTTP::Post.new(uri) request.content_type = 'application/json' request['Accept'] = 'application/json' request['Authorization'] = 'Bearer YOUR_TOKEN' request.body = JSON.dump({ query: 'mutation DriverRoutesAddOrder($routeId: Int, $ref: String, $optimize: Int) { driverRoutesAddOrder(routeId: $routeId, ref: $ref, optimize: $optimize) }', variables: {"routeId":1,"ref":"example","optimize":1} }) response = http.request(request) puts JSON.parse(response.body)

<?php require 'vendor/autoload.php'; $client = new GuzzleHttp\Client(); $response = $client->post('https://api.superlabel.ca/api/graphql', [ 'headers' => [ 'Content-Type' => 'application/json', 'Accept' => 'application/json', 'Authorization' => 'Bearer YOUR_TOKEN', ], 'json' => [ 'query' => 'mutation DriverRoutesBatchAddOrdersByDriver($routeId: Int, $order_ids: [Int]) { driverRoutesBatchAddOrdersByDriver(routeId: $routeId, order_ids: $order_ids) }', 'variables' => json_decode('{"routeId":1,"order_ids":[1]}', true), ], ]); $data = json_decode($response->getBody(), true); print_r($data);

import requests response = requests.post( 'https://api.superlabel.ca/api/graphql', headers={ 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, json={ 'query': 'mutation DriverRoutesBatchAddOrdersByDriver($routeId: Int, $order_ids: [Int]) { driverRoutesBatchAddOrdersByDriver(routeId: $routeId, order_ids: $order_ids) }', 'variables': {"routeId":1,"order_ids":[1]}, }, ) data = response.json() print(data)

package main import ( "bytes" "encoding/json" "fmt" "io" "net/http" ) func main() { payload, _ := json.Marshal(map[string]interface{}{ "query": `mutation DriverRoutesBatchAddOrdersByDriver($routeId: Int, $order_ids: [Int]) { driverRoutesBatchAddOrdersByDriver(routeId: $routeId, order_ids: $order_ids) }`, "variables": {"routeId":1,"order_ids":[1]}, }) req, _ := http.NewRequest("POST", "https://api.superlabel.ca/api/graphql", bytes.NewBuffer(payload)) req.Header.Set("Content-Type", "application/json") req.Header.Set("Accept", "application/json") req.Header.Set("Authorization", "Bearer YOUR_TOKEN") client := &http.Client{} resp, _ := client.Do(req) defer resp.Body.Close() body, _ := io.ReadAll(resp.Body) fmt.Println(string(body)) }

const response = await fetch('https://api.superlabel.ca/api/graphql', { method: 'POST', headers: { 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, body: JSON.stringify({ query: `mutation DriverRoutesBatchAddOrdersByDriver($routeId: Int, $order_ids: [Int]) { driverRoutesBatchAddOrdersByDriver(routeId: $routeId, order_ids: $order_ids) }`, variables: { "routeId": 1, "order_ids": [ 1 ] }, }), }); const data = await response.json(); console.log(data);

import java.net.http.*; import java.net.URI; HttpClient client = HttpClient.newHttpClient(); String body = "{\"query\":\"mutation DriverRoutesBatchAddOrdersByDriver($routeId: Int, $order_ids: [Int]) {\\n driverRoutesBatchAddOrdersByDriver(routeId: $routeId, order_ids: $order_ids)\\n}\",\"variables\":{\"routeId\":1,\"order_ids\":[1]}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.superlabel.ca/api/graphql")) .header("Content-Type", "application/json") .header("Accept", "application/json") .header("Authorization", "Bearer YOUR_TOKEN") .POST(HttpRequest.BodyPublishers.ofString(body)) .build(); HttpResponse<String> response = client.send( request, HttpResponse.BodyHandlers.ofString() ); System.out.println(response.body());

require 'net/http' require 'json' require 'uri' uri = URI.parse('https://api.superlabel.ca/api/graphql') http = Net::HTTP.new(uri.host, uri.port) http.use_ssl = uri.scheme == 'https' request = Net::HTTP::Post.new(uri) request.content_type = 'application/json' request['Accept'] = 'application/json' request['Authorization'] = 'Bearer YOUR_TOKEN' request.body = JSON.dump({ query: 'mutation DriverRoutesBatchAddOrdersByDriver($routeId: Int, $order_ids: [Int]) { driverRoutesBatchAddOrdersByDriver(routeId: $routeId, order_ids: $order_ids) }', variables: {"routeId":1,"order_ids":[1]} }) response = http.request(request) puts JSON.parse(response.body)

<?php require 'vendor/autoload.php'; $client = new GuzzleHttp\Client(); $response = $client->post('https://api.superlabel.ca/api/graphql', [ 'headers' => [ 'Content-Type' => 'application/json', 'Accept' => 'application/json', 'Authorization' => 'Bearer YOUR_TOKEN', ], 'json' => [ 'query' => 'mutation DriverRoutesOrdersBatchremove($routeId: Int, $order_ids: [Int]) { driverRoutesOrdersBatchremove(routeId: $routeId, order_ids: $order_ids) }', 'variables' => json_decode('{"routeId":1,"order_ids":[1]}', true), ], ]); $data = json_decode($response->getBody(), true); print_r($data);

import requests response = requests.post( 'https://api.superlabel.ca/api/graphql', headers={ 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, json={ 'query': 'mutation DriverRoutesOrdersBatchremove($routeId: Int, $order_ids: [Int]) { driverRoutesOrdersBatchremove(routeId: $routeId, order_ids: $order_ids) }', 'variables': {"routeId":1,"order_ids":[1]}, }, ) data = response.json() print(data)

package main import ( "bytes" "encoding/json" "fmt" "io" "net/http" ) func main() { payload, _ := json.Marshal(map[string]interface{}{ "query": `mutation DriverRoutesOrdersBatchremove($routeId: Int, $order_ids: [Int]) { driverRoutesOrdersBatchremove(routeId: $routeId, order_ids: $order_ids) }`, "variables": {"routeId":1,"order_ids":[1]}, }) req, _ := http.NewRequest("POST", "https://api.superlabel.ca/api/graphql", bytes.NewBuffer(payload)) req.Header.Set("Content-Type", "application/json") req.Header.Set("Accept", "application/json") req.Header.Set("Authorization", "Bearer YOUR_TOKEN") client := &http.Client{} resp, _ := client.Do(req) defer resp.Body.Close() body, _ := io.ReadAll(resp.Body) fmt.Println(string(body)) }

const response = await fetch('https://api.superlabel.ca/api/graphql', { method: 'POST', headers: { 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, body: JSON.stringify({ query: `mutation DriverRoutesOrdersBatchremove($routeId: Int, $order_ids: [Int]) { driverRoutesOrdersBatchremove(routeId: $routeId, order_ids: $order_ids) }`, variables: { "routeId": 1, "order_ids": [ 1 ] }, }), }); const data = await response.json(); console.log(data);

import java.net.http.*; import java.net.URI; HttpClient client = HttpClient.newHttpClient(); String body = "{\"query\":\"mutation DriverRoutesOrdersBatchremove($routeId: Int, $order_ids: [Int]) {\\n driverRoutesOrdersBatchremove(routeId: $routeId, order_ids: $order_ids)\\n}\",\"variables\":{\"routeId\":1,\"order_ids\":[1]}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.superlabel.ca/api/graphql")) .header("Content-Type", "application/json") .header("Accept", "application/json") .header("Authorization", "Bearer YOUR_TOKEN") .POST(HttpRequest.BodyPublishers.ofString(body)) .build(); HttpResponse<String> response = client.send( request, HttpResponse.BodyHandlers.ofString() ); System.out.println(response.body());

require 'net/http' require 'json' require 'uri' uri = URI.parse('https://api.superlabel.ca/api/graphql') http = Net::HTTP.new(uri.host, uri.port) http.use_ssl = uri.scheme == 'https' request = Net::HTTP::Post.new(uri) request.content_type = 'application/json' request['Accept'] = 'application/json' request['Authorization'] = 'Bearer YOUR_TOKEN' request.body = JSON.dump({ query: 'mutation DriverRoutesOrdersBatchremove($routeId: Int, $order_ids: [Int]) { driverRoutesOrdersBatchremove(routeId: $routeId, order_ids: $order_ids) }', variables: {"routeId":1,"order_ids":[1]} }) response = http.request(request) puts JSON.parse(response.body)

<?php require 'vendor/autoload.php'; $client = new GuzzleHttp\Client(); $response = $client->post('https://api.superlabel.ca/api/graphql', [ 'headers' => [ 'Content-Type' => 'application/json', 'Accept' => 'application/json', 'Authorization' => 'Bearer YOUR_TOKEN', ], 'json' => [ 'query' => 'mutation DriverRoutesOrdersRemove($routeId: Int, $orderId: Int) { driverRoutesOrdersRemove(routeId: $routeId, orderId: $orderId) }', 'variables' => json_decode('{"routeId":1,"orderId":1}', true), ], ]); $data = json_decode($response->getBody(), true); print_r($data);

import requests response = requests.post( 'https://api.superlabel.ca/api/graphql', headers={ 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, json={ 'query': 'mutation DriverRoutesOrdersRemove($routeId: Int, $orderId: Int) { driverRoutesOrdersRemove(routeId: $routeId, orderId: $orderId) }', 'variables': {"routeId":1,"orderId":1}, }, ) data = response.json() print(data)

package main import ( "bytes" "encoding/json" "fmt" "io" "net/http" ) func main() { payload, _ := json.Marshal(map[string]interface{}{ "query": `mutation DriverRoutesOrdersRemove($routeId: Int, $orderId: Int) { driverRoutesOrdersRemove(routeId: $routeId, orderId: $orderId) }`, "variables": {"routeId":1,"orderId":1}, }) req, _ := http.NewRequest("POST", "https://api.superlabel.ca/api/graphql", bytes.NewBuffer(payload)) req.Header.Set("Content-Type", "application/json") req.Header.Set("Accept", "application/json") req.Header.Set("Authorization", "Bearer YOUR_TOKEN") client := &http.Client{} resp, _ := client.Do(req) defer resp.Body.Close() body, _ := io.ReadAll(resp.Body) fmt.Println(string(body)) }

const response = await fetch('https://api.superlabel.ca/api/graphql', { method: 'POST', headers: { 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, body: JSON.stringify({ query: `mutation DriverRoutesOrdersRemove($routeId: Int, $orderId: Int) { driverRoutesOrdersRemove(routeId: $routeId, orderId: $orderId) }`, variables: { "routeId": 1, "orderId": 1 }, }), }); const data = await response.json(); console.log(data);

import java.net.http.*; import java.net.URI; HttpClient client = HttpClient.newHttpClient(); String body = "{\"query\":\"mutation DriverRoutesOrdersRemove($routeId: Int, $orderId: Int) {\\n driverRoutesOrdersRemove(routeId: $routeId, orderId: $orderId)\\n}\",\"variables\":{\"routeId\":1,\"orderId\":1}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.superlabel.ca/api/graphql")) .header("Content-Type", "application/json") .header("Accept", "application/json") .header("Authorization", "Bearer YOUR_TOKEN") .POST(HttpRequest.BodyPublishers.ofString(body)) .build(); HttpResponse<String> response = client.send( request, HttpResponse.BodyHandlers.ofString() ); System.out.println(response.body());

require 'net/http' require 'json' require 'uri' uri = URI.parse('https://api.superlabel.ca/api/graphql') http = Net::HTTP.new(uri.host, uri.port) http.use_ssl = uri.scheme == 'https' request = Net::HTTP::Post.new(uri) request.content_type = 'application/json' request['Accept'] = 'application/json' request['Authorization'] = 'Bearer YOUR_TOKEN' request.body = JSON.dump({ query: 'mutation DriverRoutesOrdersRemove($routeId: Int, $orderId: Int) { driverRoutesOrdersRemove(routeId: $routeId, orderId: $orderId) }', variables: {"routeId":1,"orderId":1} }) response = http.request(request) puts JSON.parse(response.body)

<?php require 'vendor/autoload.php'; $client = new GuzzleHttp\Client(); $response = $client->post('https://api.superlabel.ca/api/graphql', [ 'headers' => [ 'Content-Type' => 'application/json', 'Accept' => 'application/json', 'Authorization' => 'Bearer YOUR_TOKEN', ], 'json' => [ 'query' => 'mutation DriverRoutesValidateOrder($order_id: Int, $ref: String) { driverRoutesValidateOrder(order_id: $order_id, ref: $ref) }', 'variables' => json_decode('{"order_id":1,"ref":"example"}', true), ], ]); $data = json_decode($response->getBody(), true); print_r($data);

import requests response = requests.post( 'https://api.superlabel.ca/api/graphql', headers={ 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, json={ 'query': 'mutation DriverRoutesValidateOrder($order_id: Int, $ref: String) { driverRoutesValidateOrder(order_id: $order_id, ref: $ref) }', 'variables': {"order_id":1,"ref":"example"}, }, ) data = response.json() print(data)

package main import ( "bytes" "encoding/json" "fmt" "io" "net/http" ) func main() { payload, _ := json.Marshal(map[string]interface{}{ "query": `mutation DriverRoutesValidateOrder($order_id: Int, $ref: String) { driverRoutesValidateOrder(order_id: $order_id, ref: $ref) }`, "variables": {"order_id":1,"ref":"example"}, }) req, _ := http.NewRequest("POST", "https://api.superlabel.ca/api/graphql", bytes.NewBuffer(payload)) req.Header.Set("Content-Type", "application/json") req.Header.Set("Accept", "application/json") req.Header.Set("Authorization", "Bearer YOUR_TOKEN") client := &http.Client{} resp, _ := client.Do(req) defer resp.Body.Close() body, _ := io.ReadAll(resp.Body) fmt.Println(string(body)) }

const response = await fetch('https://api.superlabel.ca/api/graphql', { method: 'POST', headers: { 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, body: JSON.stringify({ query: `mutation DriverRoutesValidateOrder($order_id: Int, $ref: String) { driverRoutesValidateOrder(order_id: $order_id, ref: $ref) }`, variables: { "order_id": 1, "ref": "example" }, }), }); const data = await response.json(); console.log(data);

import java.net.http.*; import java.net.URI; HttpClient client = HttpClient.newHttpClient(); String body = "{\"query\":\"mutation DriverRoutesValidateOrder($order_id: Int, $ref: String) {\\n driverRoutesValidateOrder(order_id: $order_id, ref: $ref)\\n}\",\"variables\":{\"order_id\":1,\"ref\":\"example\"}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.superlabel.ca/api/graphql")) .header("Content-Type", "application/json") .header("Accept", "application/json") .header("Authorization", "Bearer YOUR_TOKEN") .POST(HttpRequest.BodyPublishers.ofString(body)) .build(); HttpResponse<String> response = client.send( request, HttpResponse.BodyHandlers.ofString() ); System.out.println(response.body());

require 'net/http' require 'json' require 'uri' uri = URI.parse('https://api.superlabel.ca/api/graphql') http = Net::HTTP.new(uri.host, uri.port) http.use_ssl = uri.scheme == 'https' request = Net::HTTP::Post.new(uri) request.content_type = 'application/json' request['Accept'] = 'application/json' request['Authorization'] = 'Bearer YOUR_TOKEN' request.body = JSON.dump({ query: 'mutation DriverRoutesValidateOrder($order_id: Int, $ref: String) { driverRoutesValidateOrder(order_id: $order_id, ref: $ref) }', variables: {"order_id":1,"ref":"example"} }) response = http.request(request) puts JSON.parse(response.body)

<?php require 'vendor/autoload.php'; $client = new GuzzleHttp\Client(); $response = $client->post('https://api.superlabel.ca/api/graphql', [ 'headers' => [ 'Content-Type' => 'application/json', 'Accept' => 'application/json', 'Authorization' => 'Bearer YOUR_TOKEN', ], 'json' => [ 'query' => 'mutation DriverStartDelivery($routeId: Int, $gps_tracking_id: Int) { driverStartDelivery(routeId: $routeId, gps_tracking_id: $gps_tracking_id) }', 'variables' => json_decode('{"routeId":1,"gps_tracking_id":1}', true), ], ]); $data = json_decode($response->getBody(), true); print_r($data);

import requests response = requests.post( 'https://api.superlabel.ca/api/graphql', headers={ 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, json={ 'query': 'mutation DriverStartDelivery($routeId: Int, $gps_tracking_id: Int) { driverStartDelivery(routeId: $routeId, gps_tracking_id: $gps_tracking_id) }', 'variables': {"routeId":1,"gps_tracking_id":1}, }, ) data = response.json() print(data)

package main import ( "bytes" "encoding/json" "fmt" "io" "net/http" ) func main() { payload, _ := json.Marshal(map[string]interface{}{ "query": `mutation DriverStartDelivery($routeId: Int, $gps_tracking_id: Int) { driverStartDelivery(routeId: $routeId, gps_tracking_id: $gps_tracking_id) }`, "variables": {"routeId":1,"gps_tracking_id":1}, }) req, _ := http.NewRequest("POST", "https://api.superlabel.ca/api/graphql", bytes.NewBuffer(payload)) req.Header.Set("Content-Type", "application/json") req.Header.Set("Accept", "application/json") req.Header.Set("Authorization", "Bearer YOUR_TOKEN") client := &http.Client{} resp, _ := client.Do(req) defer resp.Body.Close() body, _ := io.ReadAll(resp.Body) fmt.Println(string(body)) }

const response = await fetch('https://api.superlabel.ca/api/graphql', { method: 'POST', headers: { 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, body: JSON.stringify({ query: `mutation DriverStartDelivery($routeId: Int, $gps_tracking_id: Int) { driverStartDelivery(routeId: $routeId, gps_tracking_id: $gps_tracking_id) }`, variables: { "routeId": 1, "gps_tracking_id": 1 }, }), }); const data = await response.json(); console.log(data);

import java.net.http.*; import java.net.URI; HttpClient client = HttpClient.newHttpClient(); String body = "{\"query\":\"mutation DriverStartDelivery($routeId: Int, $gps_tracking_id: Int) {\\n driverStartDelivery(routeId: $routeId, gps_tracking_id: $gps_tracking_id)\\n}\",\"variables\":{\"routeId\":1,\"gps_tracking_id\":1}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.superlabel.ca/api/graphql")) .header("Content-Type", "application/json") .header("Accept", "application/json") .header("Authorization", "Bearer YOUR_TOKEN") .POST(HttpRequest.BodyPublishers.ofString(body)) .build(); HttpResponse<String> response = client.send( request, HttpResponse.BodyHandlers.ofString() ); System.out.println(response.body());

require 'net/http' require 'json' require 'uri' uri = URI.parse('https://api.superlabel.ca/api/graphql') http = Net::HTTP.new(uri.host, uri.port) http.use_ssl = uri.scheme == 'https' request = Net::HTTP::Post.new(uri) request.content_type = 'application/json' request['Accept'] = 'application/json' request['Authorization'] = 'Bearer YOUR_TOKEN' request.body = JSON.dump({ query: 'mutation DriverStartDelivery($routeId: Int, $gps_tracking_id: Int) { driverStartDelivery(routeId: $routeId, gps_tracking_id: $gps_tracking_id) }', variables: {"routeId":1,"gps_tracking_id":1} }) response = http.request(request) puts JSON.parse(response.body)

<?php require 'vendor/autoload.php'; $client = new GuzzleHttp\Client(); $response = $client->post('https://api.superlabel.ca/api/graphql', [ 'headers' => [ 'Content-Type' => 'application/json', 'Accept' => 'application/json', 'Authorization' => 'Bearer YOUR_TOKEN', ], 'json' => [ 'query' => 'mutation DriverUpdateDeliver($route_id: Int, $order_id: Int, $latitude: Float, $longitude: Float, $status_code: String, $photo_url1: String, $photo_url2: String, $photo_urls: [String], $signature_url: String, $signature_note: String, $return_reason_id: Int, $package_ids: [Int], $delivery_pin: String, $captured_at: String) { driverUpdateDeliver(route_id: $route_id, order_id: $order_id, latitude: $latitude, longitude: $longitude, status_code: $status_code, photo_url1: $photo_url1, photo_url2: $photo_url2, photo_urls: $photo_urls, signature_url: $signature_url, signature_note: $signature_note, return_reason_id: $return_reason_id, package_ids: $package_ids, delivery_pin: $delivery_pin, captured_at: $captured_at) }', 'variables' => json_decode('{"route_id":1,"order_id":1,"latitude":1.5,"longitude":1.5,"status_code":"example","photo_url1":"example","photo_url2":"example","photo_urls":["example"],"signature_url":"example","signature_note":"example","return_reason_id":1,"package_ids":[1],"delivery_pin":"example","captured_at":"2026-01-01"}', true), ], ]); $data = json_decode($response->getBody(), true); print_r($data);

import requests response = requests.post( 'https://api.superlabel.ca/api/graphql', headers={ 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, json={ 'query': 'mutation DriverUpdateDeliver($route_id: Int, $order_id: Int, $latitude: Float, $longitude: Float, $status_code: String, $photo_url1: String, $photo_url2: String, $photo_urls: [String], $signature_url: String, $signature_note: String, $return_reason_id: Int, $package_ids: [Int], $delivery_pin: String, $captured_at: String) { driverUpdateDeliver(route_id: $route_id, order_id: $order_id, latitude: $latitude, longitude: $longitude, status_code: $status_code, photo_url1: $photo_url1, photo_url2: $photo_url2, photo_urls: $photo_urls, signature_url: $signature_url, signature_note: $signature_note, return_reason_id: $return_reason_id, package_ids: $package_ids, delivery_pin: $delivery_pin, captured_at: $captured_at) }', 'variables': {"route_id":1,"order_id":1,"latitude":1.5,"longitude":1.5,"status_code":"example","photo_url1":"example","photo_url2":"example","photo_urls":["example"],"signature_url":"example","signature_note":"example","return_reason_id":1,"package_ids":[1],"delivery_pin":"example","captured_at":"2026-01-01"}, }, ) data = response.json() print(data)

package main import ( "bytes" "encoding/json" "fmt" "io" "net/http" ) func main() { payload, _ := json.Marshal(map[string]interface{}{ "query": `mutation DriverUpdateDeliver($route_id: Int, $order_id: Int, $latitude: Float, $longitude: Float, $status_code: String, $photo_url1: String, $photo_url2: String, $photo_urls: [String], $signature_url: String, $signature_note: String, $return_reason_id: Int, $package_ids: [Int], $delivery_pin: String, $captured_at: String) { driverUpdateDeliver(route_id: $route_id, order_id: $order_id, latitude: $latitude, longitude: $longitude, status_code: $status_code, photo_url1: $photo_url1, photo_url2: $photo_url2, photo_urls: $photo_urls, signature_url: $signature_url, signature_note: $signature_note, return_reason_id: $return_reason_id, package_ids: $package_ids, delivery_pin: $delivery_pin, captured_at: $captured_at) }`, "variables": {"route_id":1,"order_id":1,"latitude":1.5,"longitude":1.5,"status_code":"example","photo_url1":"example","photo_url2":"example","photo_urls":["example"],"signature_url":"example","signature_note":"example","return_reason_id":1,"package_ids":[1],"delivery_pin":"example","captured_at":"2026-01-01"}, }) req, _ := http.NewRequest("POST", "https://api.superlabel.ca/api/graphql", bytes.NewBuffer(payload)) req.Header.Set("Content-Type", "application/json") req.Header.Set("Accept", "application/json") req.Header.Set("Authorization", "Bearer YOUR_TOKEN") client := &http.Client{} resp, _ := client.Do(req) defer resp.Body.Close() body, _ := io.ReadAll(resp.Body) fmt.Println(string(body)) }

const response = await fetch('https://api.superlabel.ca/api/graphql', { method: 'POST', headers: { 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, body: JSON.stringify({ query: `mutation DriverUpdateDeliver($route_id: Int, $order_id: Int, $latitude: Float, $longitude: Float, $status_code: String, $photo_url1: String, $photo_url2: String, $photo_urls: [String], $signature_url: String, $signature_note: String, $return_reason_id: Int, $package_ids: [Int], $delivery_pin: String, $captured_at: String) { driverUpdateDeliver(route_id: $route_id, order_id: $order_id, latitude: $latitude, longitude: $longitude, status_code: $status_code, photo_url1: $photo_url1, photo_url2: $photo_url2, photo_urls: $photo_urls, signature_url: $signature_url, signature_note: $signature_note, return_reason_id: $return_reason_id, package_ids: $package_ids, delivery_pin: $delivery_pin, captured_at: $captured_at) }`, variables: { "route_id": 1, "order_id": 1, "latitude": 1.5, "longitude": 1.5, "status_code": "example", "photo_url1": "example", "photo_url2": "example", "photo_urls": [ "example" ], "signature_url": "example", "signature_note": "example", "return_reason_id": 1, "package_ids": [ 1 ], "delivery_pin": "example", "captured_at": "2026-01-01" }, }), }); const data = await response.json(); console.log(data);

import java.net.http.*; import java.net.URI; HttpClient client = HttpClient.newHttpClient(); String body = "{\"query\":\"mutation DriverUpdateDeliver($route_id: Int, $order_id: Int, $latitude: Float, $longitude: Float, $status_code: String, $photo_url1: String, $photo_url2: String, $photo_urls: [String], $signature_url: String, $signature_note: String, $return_reason_id: Int, $package_ids: [Int], $delivery_pin: String, $captured_at: String) {\\n driverUpdateDeliver(route_id: $route_id, order_id: $order_id, latitude: $latitude, longitude: $longitude, status_code: $status_code, photo_url1: $photo_url1, photo_url2: $photo_url2, photo_urls: $photo_urls, signature_url: $signature_url, signature_note: $signature_note, return_reason_id: $return_reason_id, package_ids: $package_ids, delivery_pin: $delivery_pin, captured_at: $captured_at)\\n}\",\"variables\":{\"route_id\":1,\"order_id\":1,\"latitude\":1.5,\"longitude\":1.5,\"status_code\":\"example\",\"photo_url1\":\"example\",\"photo_url2\":\"example\",\"photo_urls\":[\"example\"],\"signature_url\":\"example\",\"signature_note\":\"example\",\"return_reason_id\":1,\"package_ids\":[1],\"delivery_pin\":\"example\",\"captured_at\":\"2026-01-01\"}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.superlabel.ca/api/graphql")) .header("Content-Type", "application/json") .header("Accept", "application/json") .header("Authorization", "Bearer YOUR_TOKEN") .POST(HttpRequest.BodyPublishers.ofString(body)) .build(); HttpResponse<String> response = client.send( request, HttpResponse.BodyHandlers.ofString() ); System.out.println(response.body());

require 'net/http' require 'json' require 'uri' uri = URI.parse('https://api.superlabel.ca/api/graphql') http = Net::HTTP.new(uri.host, uri.port) http.use_ssl = uri.scheme == 'https' request = Net::HTTP::Post.new(uri) request.content_type = 'application/json' request['Accept'] = 'application/json' request['Authorization'] = 'Bearer YOUR_TOKEN' request.body = JSON.dump({ query: 'mutation DriverUpdateDeliver($route_id: Int, $order_id: Int, $latitude: Float, $longitude: Float, $status_code: String, $photo_url1: String, $photo_url2: String, $photo_urls: [String], $signature_url: String, $signature_note: String, $return_reason_id: Int, $package_ids: [Int], $delivery_pin: String, $captured_at: String) { driverUpdateDeliver(route_id: $route_id, order_id: $order_id, latitude: $latitude, longitude: $longitude, status_code: $status_code, photo_url1: $photo_url1, photo_url2: $photo_url2, photo_urls: $photo_urls, signature_url: $signature_url, signature_note: $signature_note, return_reason_id: $return_reason_id, package_ids: $package_ids, delivery_pin: $delivery_pin, captured_at: $captured_at) }', variables: {"route_id":1,"order_id":1,"latitude":1.5,"longitude":1.5,"status_code":"example","photo_url1":"example","photo_url2":"example","photo_urls":["example"],"signature_url":"example","signature_note":"example","return_reason_id":1,"package_ids":[1],"delivery_pin":"example","captured_at":"2026-01-01"} }) response = http.request(request) puts JSON.parse(response.body)

<?php require 'vendor/autoload.php'; $client = new GuzzleHttp\Client(); $response = $client->post('https://api.superlabel.ca/api/graphql', [ 'headers' => [ 'Content-Type' => 'application/json', 'Accept' => 'application/json', 'Authorization' => 'Bearer YOUR_TOKEN', ], 'json' => [ 'query' => 'mutation DriverUpdateFcmToken($fcm_token: String!, $device_type: String, $device_id: String, $preferred_language: String, $firebase_short_code: String!) { driverUpdateFcmToken(fcm_token: $fcm_token, device_type: $device_type, device_id: $device_id, preferred_language: $preferred_language, firebase_short_code: $firebase_short_code) }', 'variables' => json_decode('{"fcm_token":"example","device_type":"example","device_id":"example","preferred_language":"example","firebase_short_code":"example"}', true), ], ]); $data = json_decode($response->getBody(), true); print_r($data);

import requests response = requests.post( 'https://api.superlabel.ca/api/graphql', headers={ 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, json={ 'query': 'mutation DriverUpdateFcmToken($fcm_token: String!, $device_type: String, $device_id: String, $preferred_language: String, $firebase_short_code: String!) { driverUpdateFcmToken(fcm_token: $fcm_token, device_type: $device_type, device_id: $device_id, preferred_language: $preferred_language, firebase_short_code: $firebase_short_code) }', 'variables': {"fcm_token":"example","device_type":"example","device_id":"example","preferred_language":"example","firebase_short_code":"example"}, }, ) data = response.json() print(data)

package main import ( "bytes" "encoding/json" "fmt" "io" "net/http" ) func main() { payload, _ := json.Marshal(map[string]interface{}{ "query": `mutation DriverUpdateFcmToken($fcm_token: String!, $device_type: String, $device_id: String, $preferred_language: String, $firebase_short_code: String!) { driverUpdateFcmToken(fcm_token: $fcm_token, device_type: $device_type, device_id: $device_id, preferred_language: $preferred_language, firebase_short_code: $firebase_short_code) }`, "variables": {"fcm_token":"example","device_type":"example","device_id":"example","preferred_language":"example","firebase_short_code":"example"}, }) req, _ := http.NewRequest("POST", "https://api.superlabel.ca/api/graphql", bytes.NewBuffer(payload)) req.Header.Set("Content-Type", "application/json") req.Header.Set("Accept", "application/json") req.Header.Set("Authorization", "Bearer YOUR_TOKEN") client := &http.Client{} resp, _ := client.Do(req) defer resp.Body.Close() body, _ := io.ReadAll(resp.Body) fmt.Println(string(body)) }

const response = await fetch('https://api.superlabel.ca/api/graphql', { method: 'POST', headers: { 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, body: JSON.stringify({ query: `mutation DriverUpdateFcmToken($fcm_token: String!, $device_type: String, $device_id: String, $preferred_language: String, $firebase_short_code: String!) { driverUpdateFcmToken(fcm_token: $fcm_token, device_type: $device_type, device_id: $device_id, preferred_language: $preferred_language, firebase_short_code: $firebase_short_code) }`, variables: { "fcm_token": "example", "device_type": "example", "device_id": "example", "preferred_language": "example", "firebase_short_code": "example" }, }), }); const data = await response.json(); console.log(data);

import java.net.http.*; import java.net.URI; HttpClient client = HttpClient.newHttpClient(); String body = "{\"query\":\"mutation DriverUpdateFcmToken($fcm_token: String!, $device_type: String, $device_id: String, $preferred_language: String, $firebase_short_code: String!) {\\n driverUpdateFcmToken(fcm_token: $fcm_token, device_type: $device_type, device_id: $device_id, preferred_language: $preferred_language, firebase_short_code: $firebase_short_code)\\n}\",\"variables\":{\"fcm_token\":\"example\",\"device_type\":\"example\",\"device_id\":\"example\",\"preferred_language\":\"example\",\"firebase_short_code\":\"example\"}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.superlabel.ca/api/graphql")) .header("Content-Type", "application/json") .header("Accept", "application/json") .header("Authorization", "Bearer YOUR_TOKEN") .POST(HttpRequest.BodyPublishers.ofString(body)) .build(); HttpResponse<String> response = client.send( request, HttpResponse.BodyHandlers.ofString() ); System.out.println(response.body());

require 'net/http' require 'json' require 'uri' uri = URI.parse('https://api.superlabel.ca/api/graphql') http = Net::HTTP.new(uri.host, uri.port) http.use_ssl = uri.scheme == 'https' request = Net::HTTP::Post.new(uri) request.content_type = 'application/json' request['Accept'] = 'application/json' request['Authorization'] = 'Bearer YOUR_TOKEN' request.body = JSON.dump({ query: 'mutation DriverUpdateFcmToken($fcm_token: String!, $device_type: String, $device_id: String, $preferred_language: String, $firebase_short_code: String!) { driverUpdateFcmToken(fcm_token: $fcm_token, device_type: $device_type, device_id: $device_id, preferred_language: $preferred_language, firebase_short_code: $firebase_short_code) }', variables: {"fcm_token":"example","device_type":"example","device_id":"example","preferred_language":"example","firebase_short_code":"example"} }) response = http.request(request) puts JSON.parse(response.body)

<?php require 'vendor/autoload.php'; $client = new GuzzleHttp\Client(); $response = $client->post('https://api.superlabel.ca/api/graphql', [ 'headers' => [ 'Content-Type' => 'application/json', 'Accept' => 'application/json', 'Authorization' => 'Bearer YOUR_TOKEN', ], 'json' => [ 'query' => 'mutation DriverUploadPictures($orderId: Int, $type: String, $image: String, $imageUrl: String, $gps_tracking_id: Int, $operation_event_id: Int, $note: String) { driverUploadPictures(orderId: $orderId, type: $type, image: $image, imageUrl: $imageUrl, gps_tracking_id: $gps_tracking_id, operation_event_id: $operation_event_id, note: $note) }', 'variables' => json_decode('{"orderId":1,"type":"example","image":"example","imageUrl":"example","gps_tracking_id":1,"operation_event_id":1,"note":"example"}', true), ], ]); $data = json_decode($response->getBody(), true); print_r($data);

import requests response = requests.post( 'https://api.superlabel.ca/api/graphql', headers={ 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, json={ 'query': 'mutation DriverUploadPictures($orderId: Int, $type: String, $image: String, $imageUrl: String, $gps_tracking_id: Int, $operation_event_id: Int, $note: String) { driverUploadPictures(orderId: $orderId, type: $type, image: $image, imageUrl: $imageUrl, gps_tracking_id: $gps_tracking_id, operation_event_id: $operation_event_id, note: $note) }', 'variables': {"orderId":1,"type":"example","image":"example","imageUrl":"example","gps_tracking_id":1,"operation_event_id":1,"note":"example"}, }, ) data = response.json() print(data)

package main import ( "bytes" "encoding/json" "fmt" "io" "net/http" ) func main() { payload, _ := json.Marshal(map[string]interface{}{ "query": `mutation DriverUploadPictures($orderId: Int, $type: String, $image: String, $imageUrl: String, $gps_tracking_id: Int, $operation_event_id: Int, $note: String) { driverUploadPictures(orderId: $orderId, type: $type, image: $image, imageUrl: $imageUrl, gps_tracking_id: $gps_tracking_id, operation_event_id: $operation_event_id, note: $note) }`, "variables": {"orderId":1,"type":"example","image":"example","imageUrl":"example","gps_tracking_id":1,"operation_event_id":1,"note":"example"}, }) req, _ := http.NewRequest("POST", "https://api.superlabel.ca/api/graphql", bytes.NewBuffer(payload)) req.Header.Set("Content-Type", "application/json") req.Header.Set("Accept", "application/json") req.Header.Set("Authorization", "Bearer YOUR_TOKEN") client := &http.Client{} resp, _ := client.Do(req) defer resp.Body.Close() body, _ := io.ReadAll(resp.Body) fmt.Println(string(body)) }

const response = await fetch('https://api.superlabel.ca/api/graphql', { method: 'POST', headers: { 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, body: JSON.stringify({ query: `mutation DriverUploadPictures($orderId: Int, $type: String, $image: String, $imageUrl: String, $gps_tracking_id: Int, $operation_event_id: Int, $note: String) { driverUploadPictures(orderId: $orderId, type: $type, image: $image, imageUrl: $imageUrl, gps_tracking_id: $gps_tracking_id, operation_event_id: $operation_event_id, note: $note) }`, variables: { "orderId": 1, "type": "example", "image": "example", "imageUrl": "example", "gps_tracking_id": 1, "operation_event_id": 1, "note": "example" }, }), }); const data = await response.json(); console.log(data);

import java.net.http.*; import java.net.URI; HttpClient client = HttpClient.newHttpClient(); String body = "{\"query\":\"mutation DriverUploadPictures($orderId: Int, $type: String, $image: String, $imageUrl: String, $gps_tracking_id: Int, $operation_event_id: Int, $note: String) {\\n driverUploadPictures(orderId: $orderId, type: $type, image: $image, imageUrl: $imageUrl, gps_tracking_id: $gps_tracking_id, operation_event_id: $operation_event_id, note: $note)\\n}\",\"variables\":{\"orderId\":1,\"type\":\"example\",\"image\":\"example\",\"imageUrl\":\"example\",\"gps_tracking_id\":1,\"operation_event_id\":1,\"note\":\"example\"}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.superlabel.ca/api/graphql")) .header("Content-Type", "application/json") .header("Accept", "application/json") .header("Authorization", "Bearer YOUR_TOKEN") .POST(HttpRequest.BodyPublishers.ofString(body)) .build(); HttpResponse<String> response = client.send( request, HttpResponse.BodyHandlers.ofString() ); System.out.println(response.body());

require 'net/http' require 'json' require 'uri' uri = URI.parse('https://api.superlabel.ca/api/graphql') http = Net::HTTP.new(uri.host, uri.port) http.use_ssl = uri.scheme == 'https' request = Net::HTTP::Post.new(uri) request.content_type = 'application/json' request['Accept'] = 'application/json' request['Authorization'] = 'Bearer YOUR_TOKEN' request.body = JSON.dump({ query: 'mutation DriverUploadPictures($orderId: Int, $type: String, $image: String, $imageUrl: String, $gps_tracking_id: Int, $operation_event_id: Int, $note: String) { driverUploadPictures(orderId: $orderId, type: $type, image: $image, imageUrl: $imageUrl, gps_tracking_id: $gps_tracking_id, operation_event_id: $operation_event_id, note: $note) }', variables: {"orderId":1,"type":"example","image":"example","imageUrl":"example","gps_tracking_id":1,"operation_event_id":1,"note":"example"} }) response = http.request(request) puts JSON.parse(response.body)

<?php require 'vendor/autoload.php'; $client = new GuzzleHttp\Client(); $response = $client->post('https://api.superlabel.ca/api/graphql', [ 'headers' => [ 'Content-Type' => 'application/json', 'Accept' => 'application/json', 'Authorization' => 'Bearer YOUR_TOKEN', ], 'json' => [ 'query' => 'mutation Driverinfo($business_id: Int, $name: String, $alias: String, $email: String, $password: String, $telephone: String, $language: String, $address: String, $address_2: String, $city: String, $province: String, $country: String, $postcode: String, $capacity: Int, $vehicle_type: Int, $fuel_type: Int, $territory_id: Int, $start_location_id: Int, $end_location_id: Int, $status: Int, $skills: [Int]) { driverinfo(business_id: $business_id, name: $name, alias: $alias, email: $email, password: $password, telephone: $telephone, language: $language, address: $address, address_2: $address_2, city: $city, province: $province, country: $country, postcode: $postcode, capacity: $capacity, vehicle_type: $vehicle_type, fuel_type: $fuel_type, territory_id: $territory_id, start_location_id: $start_location_id, end_location_id: $end_location_id, status: $status, skills: $skills) }', 'variables' => json_decode('{"business_id":1,"name":"example","alias":"example","email":"user@example.com","password":"example","telephone":"+14165551234","language":"example","address":"example","address_2":"example","city":"Toronto","province":"ON","country":"CA","postcode":"M5V 2T6","capacity":1,"vehicle_type":1,"fuel_type":1,"territory_id":1,"start_location_id":1,"end_location_id":1,"status":1,"skills":[1]}', true), ], ]); $data = json_decode($response->getBody(), true); print_r($data);

import requests response = requests.post( 'https://api.superlabel.ca/api/graphql', headers={ 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, json={ 'query': 'mutation Driverinfo($business_id: Int, $name: String, $alias: String, $email: String, $password: String, $telephone: String, $language: String, $address: String, $address_2: String, $city: String, $province: String, $country: String, $postcode: String, $capacity: Int, $vehicle_type: Int, $fuel_type: Int, $territory_id: Int, $start_location_id: Int, $end_location_id: Int, $status: Int, $skills: [Int]) { driverinfo(business_id: $business_id, name: $name, alias: $alias, email: $email, password: $password, telephone: $telephone, language: $language, address: $address, address_2: $address_2, city: $city, province: $province, country: $country, postcode: $postcode, capacity: $capacity, vehicle_type: $vehicle_type, fuel_type: $fuel_type, territory_id: $territory_id, start_location_id: $start_location_id, end_location_id: $end_location_id, status: $status, skills: $skills) }', 'variables': {"business_id":1,"name":"example","alias":"example","email":"user@example.com","password":"example","telephone":"+14165551234","language":"example","address":"example","address_2":"example","city":"Toronto","province":"ON","country":"CA","postcode":"M5V 2T6","capacity":1,"vehicle_type":1,"fuel_type":1,"territory_id":1,"start_location_id":1,"end_location_id":1,"status":1,"skills":[1]}, }, ) data = response.json() print(data)

package main import ( "bytes" "encoding/json" "fmt" "io" "net/http" ) func main() { payload, _ := json.Marshal(map[string]interface{}{ "query": `mutation Driverinfo($business_id: Int, $name: String, $alias: String, $email: String, $password: String, $telephone: String, $language: String, $address: String, $address_2: String, $city: String, $province: String, $country: String, $postcode: String, $capacity: Int, $vehicle_type: Int, $fuel_type: Int, $territory_id: Int, $start_location_id: Int, $end_location_id: Int, $status: Int, $skills: [Int]) { driverinfo(business_id: $business_id, name: $name, alias: $alias, email: $email, password: $password, telephone: $telephone, language: $language, address: $address, address_2: $address_2, city: $city, province: $province, country: $country, postcode: $postcode, capacity: $capacity, vehicle_type: $vehicle_type, fuel_type: $fuel_type, territory_id: $territory_id, start_location_id: $start_location_id, end_location_id: $end_location_id, status: $status, skills: $skills) }`, "variables": {"business_id":1,"name":"example","alias":"example","email":"user@example.com","password":"example","telephone":"+14165551234","language":"example","address":"example","address_2":"example","city":"Toronto","province":"ON","country":"CA","postcode":"M5V 2T6","capacity":1,"vehicle_type":1,"fuel_type":1,"territory_id":1,"start_location_id":1,"end_location_id":1,"status":1,"skills":[1]}, }) req, _ := http.NewRequest("POST", "https://api.superlabel.ca/api/graphql", bytes.NewBuffer(payload)) req.Header.Set("Content-Type", "application/json") req.Header.Set("Accept", "application/json") req.Header.Set("Authorization", "Bearer YOUR_TOKEN") client := &http.Client{} resp, _ := client.Do(req) defer resp.Body.Close() body, _ := io.ReadAll(resp.Body) fmt.Println(string(body)) }

const response = await fetch('https://api.superlabel.ca/api/graphql', { method: 'POST', headers: { 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, body: JSON.stringify({ query: `mutation Driverinfo($business_id: Int, $name: String, $alias: String, $email: String, $password: String, $telephone: String, $language: String, $address: String, $address_2: String, $city: String, $province: String, $country: String, $postcode: String, $capacity: Int, $vehicle_type: Int, $fuel_type: Int, $territory_id: Int, $start_location_id: Int, $end_location_id: Int, $status: Int, $skills: [Int]) { driverinfo(business_id: $business_id, name: $name, alias: $alias, email: $email, password: $password, telephone: $telephone, language: $language, address: $address, address_2: $address_2, city: $city, province: $province, country: $country, postcode: $postcode, capacity: $capacity, vehicle_type: $vehicle_type, fuel_type: $fuel_type, territory_id: $territory_id, start_location_id: $start_location_id, end_location_id: $end_location_id, status: $status, skills: $skills) }`, variables: { "business_id": 1, "name": "example", "alias": "example", "email": "user@example.com", "password": "example", "telephone": "+14165551234", "language": "example", "address": "example", "address_2": "example", "city": "Toronto", "province": "ON", "country": "CA", "postcode": "M5V 2T6", "capacity": 1, "vehicle_type": 1, "fuel_type": 1, "territory_id": 1, "start_location_id": 1, "end_location_id": 1, "status": 1, "skills": [ 1 ] }, }), }); const data = await response.json(); console.log(data);

import java.net.http.*; import java.net.URI; HttpClient client = HttpClient.newHttpClient(); String body = "{\"query\":\"mutation Driverinfo($business_id: Int, $name: String, $alias: String, $email: String, $password: String, $telephone: String, $language: String, $address: String, $address_2: String, $city: String, $province: String, $country: String, $postcode: String, $capacity: Int, $vehicle_type: Int, $fuel_type: Int, $territory_id: Int, $start_location_id: Int, $end_location_id: Int, $status: Int, $skills: [Int]) {\\n driverinfo(business_id: $business_id, name: $name, alias: $alias, email: $email, password: $password, telephone: $telephone, language: $language, address: $address, address_2: $address_2, city: $city, province: $province, country: $country, postcode: $postcode, capacity: $capacity, vehicle_type: $vehicle_type, fuel_type: $fuel_type, territory_id: $territory_id, start_location_id: $start_location_id, end_location_id: $end_location_id, status: $status, skills: $skills)\\n}\",\"variables\":{\"business_id\":1,\"name\":\"example\",\"alias\":\"example\",\"email\":\"user@example.com\",\"password\":\"example\",\"telephone\":\"+14165551234\",\"language\":\"example\",\"address\":\"example\",\"address_2\":\"example\",\"city\":\"Toronto\",\"province\":\"ON\",\"country\":\"CA\",\"postcode\":\"M5V 2T6\",\"capacity\":1,\"vehicle_type\":1,\"fuel_type\":1,\"territory_id\":1,\"start_location_id\":1,\"end_location_id\":1,\"status\":1,\"skills\":[1]}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.superlabel.ca/api/graphql")) .header("Content-Type", "application/json") .header("Accept", "application/json") .header("Authorization", "Bearer YOUR_TOKEN") .POST(HttpRequest.BodyPublishers.ofString(body)) .build(); HttpResponse<String> response = client.send( request, HttpResponse.BodyHandlers.ofString() ); System.out.println(response.body());

require 'net/http' require 'json' require 'uri' uri = URI.parse('https://api.superlabel.ca/api/graphql') http = Net::HTTP.new(uri.host, uri.port) http.use_ssl = uri.scheme == 'https' request = Net::HTTP::Post.new(uri) request.content_type = 'application/json' request['Accept'] = 'application/json' request['Authorization'] = 'Bearer YOUR_TOKEN' request.body = JSON.dump({ query: 'mutation Driverinfo($business_id: Int, $name: String, $alias: String, $email: String, $password: String, $telephone: String, $language: String, $address: String, $address_2: String, $city: String, $province: String, $country: String, $postcode: String, $capacity: Int, $vehicle_type: Int, $fuel_type: Int, $territory_id: Int, $start_location_id: Int, $end_location_id: Int, $status: Int, $skills: [Int]) { driverinfo(business_id: $business_id, name: $name, alias: $alias, email: $email, password: $password, telephone: $telephone, language: $language, address: $address, address_2: $address_2, city: $city, province: $province, country: $country, postcode: $postcode, capacity: $capacity, vehicle_type: $vehicle_type, fuel_type: $fuel_type, territory_id: $territory_id, start_location_id: $start_location_id, end_location_id: $end_location_id, status: $status, skills: $skills) }', variables: {"business_id":1,"name":"example","alias":"example","email":"user@example.com","password":"example","telephone":"+14165551234","language":"example","address":"example","address_2":"example","city":"Toronto","province":"ON","country":"CA","postcode":"M5V 2T6","capacity":1,"vehicle_type":1,"fuel_type":1,"territory_id":1,"start_location_id":1,"end_location_id":1,"status":1,"skills":[1]} }) response = http.request(request) puts JSON.parse(response.body)

<?php require 'vendor/autoload.php'; $client = new GuzzleHttp\Client(); $response = $client->post('https://api.superlabel.ca/api/graphql', [ 'headers' => [ 'Content-Type' => 'application/json', 'Accept' => 'application/json', 'Authorization' => 'Bearer YOUR_TOKEN', ], 'json' => [ 'query' => 'mutation DriverinfoDelete($driver_id: Int!) { driverinfoDelete(driver_id: $driver_id) }', 'variables' => json_decode('{"driver_id":1}', true), ], ]); $data = json_decode($response->getBody(), true); print_r($data);

import requests response = requests.post( 'https://api.superlabel.ca/api/graphql', headers={ 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, json={ 'query': 'mutation DriverinfoDelete($driver_id: Int!) { driverinfoDelete(driver_id: $driver_id) }', 'variables': {"driver_id":1}, }, ) data = response.json() print(data)

package main import ( "bytes" "encoding/json" "fmt" "io" "net/http" ) func main() { payload, _ := json.Marshal(map[string]interface{}{ "query": `mutation DriverinfoDelete($driver_id: Int!) { driverinfoDelete(driver_id: $driver_id) }`, "variables": {"driver_id":1}, }) req, _ := http.NewRequest("POST", "https://api.superlabel.ca/api/graphql", bytes.NewBuffer(payload)) req.Header.Set("Content-Type", "application/json") req.Header.Set("Accept", "application/json") req.Header.Set("Authorization", "Bearer YOUR_TOKEN") client := &http.Client{} resp, _ := client.Do(req) defer resp.Body.Close() body, _ := io.ReadAll(resp.Body) fmt.Println(string(body)) }

const response = await fetch('https://api.superlabel.ca/api/graphql', { method: 'POST', headers: { 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, body: JSON.stringify({ query: `mutation DriverinfoDelete($driver_id: Int!) { driverinfoDelete(driver_id: $driver_id) }`, variables: { "driver_id": 1 }, }), }); const data = await response.json(); console.log(data);

import java.net.http.*; import java.net.URI; HttpClient client = HttpClient.newHttpClient(); String body = "{\"query\":\"mutation DriverinfoDelete($driver_id: Int!) {\\n driverinfoDelete(driver_id: $driver_id)\\n}\",\"variables\":{\"driver_id\":1}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.superlabel.ca/api/graphql")) .header("Content-Type", "application/json") .header("Accept", "application/json") .header("Authorization", "Bearer YOUR_TOKEN") .POST(HttpRequest.BodyPublishers.ofString(body)) .build(); HttpResponse<String> response = client.send( request, HttpResponse.BodyHandlers.ofString() ); System.out.println(response.body());

require 'net/http' require 'json' require 'uri' uri = URI.parse('https://api.superlabel.ca/api/graphql') http = Net::HTTP.new(uri.host, uri.port) http.use_ssl = uri.scheme == 'https' request = Net::HTTP::Post.new(uri) request.content_type = 'application/json' request['Accept'] = 'application/json' request['Authorization'] = 'Bearer YOUR_TOKEN' request.body = JSON.dump({ query: 'mutation DriverinfoDelete($driver_id: Int!) { driverinfoDelete(driver_id: $driver_id) }', variables: {"driver_id":1} }) response = http.request(request) puts JSON.parse(response.body)

<?php require 'vendor/autoload.php'; $client = new GuzzleHttp\Client(); $response = $client->post('https://api.superlabel.ca/api/graphql', [ 'headers' => [ 'Content-Type' => 'application/json', 'Accept' => 'application/json', 'Authorization' => 'Bearer YOUR_TOKEN', ], 'json' => [ 'query' => 'mutation ClientBatchOrderCreate($orders: Json) { clientBatchOrderCreate(orders: $orders) }', 'variables' => json_decode('{"orders":{"key":"value"}}', true), ], ]); $data = json_decode($response->getBody(), true); print_r($data);

import requests response = requests.post( 'https://api.superlabel.ca/api/graphql', headers={ 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, json={ 'query': 'mutation ClientBatchOrderCreate($orders: Json) { clientBatchOrderCreate(orders: $orders) }', 'variables': {"orders":{"key":"value"}}, }, ) data = response.json() print(data)

package main import ( "bytes" "encoding/json" "fmt" "io" "net/http" ) func main() { payload, _ := json.Marshal(map[string]interface{}{ "query": `mutation ClientBatchOrderCreate($orders: Json) { clientBatchOrderCreate(orders: $orders) }`, "variables": {"orders":{"key":"value"}}, }) req, _ := http.NewRequest("POST", "https://api.superlabel.ca/api/graphql", bytes.NewBuffer(payload)) req.Header.Set("Content-Type", "application/json") req.Header.Set("Accept", "application/json") req.Header.Set("Authorization", "Bearer YOUR_TOKEN") client := &http.Client{} resp, _ := client.Do(req) defer resp.Body.Close() body, _ := io.ReadAll(resp.Body) fmt.Println(string(body)) }

const response = await fetch('https://api.superlabel.ca/api/graphql', { method: 'POST', headers: { 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, body: JSON.stringify({ query: `mutation ClientBatchOrderCreate($orders: Json) { clientBatchOrderCreate(orders: $orders) }`, variables: { "orders": { "key": "value" } }, }), }); const data = await response.json(); console.log(data);

import java.net.http.*; import java.net.URI; HttpClient client = HttpClient.newHttpClient(); String body = "{\"query\":\"mutation ClientBatchOrderCreate($orders: Json) {\\n clientBatchOrderCreate(orders: $orders)\\n}\",\"variables\":{\"orders\":{\"key\":\"value\"}}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.superlabel.ca/api/graphql")) .header("Content-Type", "application/json") .header("Accept", "application/json") .header("Authorization", "Bearer YOUR_TOKEN") .POST(HttpRequest.BodyPublishers.ofString(body)) .build(); HttpResponse<String> response = client.send( request, HttpResponse.BodyHandlers.ofString() ); System.out.println(response.body());

require 'net/http' require 'json' require 'uri' uri = URI.parse('https://api.superlabel.ca/api/graphql') http = Net::HTTP.new(uri.host, uri.port) http.use_ssl = uri.scheme == 'https' request = Net::HTTP::Post.new(uri) request.content_type = 'application/json' request['Accept'] = 'application/json' request['Authorization'] = 'Bearer YOUR_TOKEN' request.body = JSON.dump({ query: 'mutation ClientBatchOrderCreate($orders: Json) { clientBatchOrderCreate(orders: $orders) }', variables: {"orders":{"key":"value"}} }) response = http.request(request) puts JSON.parse(response.body)

<?php require 'vendor/autoload.php'; $client = new GuzzleHttp\Client(); $response = $client->post('https://api.superlabel.ca/api/graphql', [ 'headers' => [ 'Content-Type' => 'application/json', 'Accept' => 'application/json', 'Authorization' => 'Bearer YOUR_TOKEN', ], 'json' => [ 'query' => 'mutation ClientBatchOrderCreateAsync($orders: Json) { clientBatchOrderCreateAsync(orders: $orders) }', 'variables' => json_decode('{"orders":{"key":"value"}}', true), ], ]); $data = json_decode($response->getBody(), true); print_r($data);

import requests response = requests.post( 'https://api.superlabel.ca/api/graphql', headers={ 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, json={ 'query': 'mutation ClientBatchOrderCreateAsync($orders: Json) { clientBatchOrderCreateAsync(orders: $orders) }', 'variables': {"orders":{"key":"value"}}, }, ) data = response.json() print(data)

package main import ( "bytes" "encoding/json" "fmt" "io" "net/http" ) func main() { payload, _ := json.Marshal(map[string]interface{}{ "query": `mutation ClientBatchOrderCreateAsync($orders: Json) { clientBatchOrderCreateAsync(orders: $orders) }`, "variables": {"orders":{"key":"value"}}, }) req, _ := http.NewRequest("POST", "https://api.superlabel.ca/api/graphql", bytes.NewBuffer(payload)) req.Header.Set("Content-Type", "application/json") req.Header.Set("Accept", "application/json") req.Header.Set("Authorization", "Bearer YOUR_TOKEN") client := &http.Client{} resp, _ := client.Do(req) defer resp.Body.Close() body, _ := io.ReadAll(resp.Body) fmt.Println(string(body)) }

const response = await fetch('https://api.superlabel.ca/api/graphql', { method: 'POST', headers: { 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, body: JSON.stringify({ query: `mutation ClientBatchOrderCreateAsync($orders: Json) { clientBatchOrderCreateAsync(orders: $orders) }`, variables: { "orders": { "key": "value" } }, }), }); const data = await response.json(); console.log(data);

import java.net.http.*; import java.net.URI; HttpClient client = HttpClient.newHttpClient(); String body = "{\"query\":\"mutation ClientBatchOrderCreateAsync($orders: Json) {\\n clientBatchOrderCreateAsync(orders: $orders)\\n}\",\"variables\":{\"orders\":{\"key\":\"value\"}}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.superlabel.ca/api/graphql")) .header("Content-Type", "application/json") .header("Accept", "application/json") .header("Authorization", "Bearer YOUR_TOKEN") .POST(HttpRequest.BodyPublishers.ofString(body)) .build(); HttpResponse<String> response = client.send( request, HttpResponse.BodyHandlers.ofString() ); System.out.println(response.body());

require 'net/http' require 'json' require 'uri' uri = URI.parse('https://api.superlabel.ca/api/graphql') http = Net::HTTP.new(uri.host, uri.port) http.use_ssl = uri.scheme == 'https' request = Net::HTTP::Post.new(uri) request.content_type = 'application/json' request['Accept'] = 'application/json' request['Authorization'] = 'Bearer YOUR_TOKEN' request.body = JSON.dump({ query: 'mutation ClientBatchOrderCreateAsync($orders: Json) { clientBatchOrderCreateAsync(orders: $orders) }', variables: {"orders":{"key":"value"}} }) response = http.request(request) puts JSON.parse(response.body)

<?php require 'vendor/autoload.php'; $client = new GuzzleHttp\Client(); $response = $client->post('https://api.superlabel.ca/api/graphql', [ 'headers' => [ 'Content-Type' => 'application/json', 'Accept' => 'application/json', 'Authorization' => 'Bearer YOUR_TOKEN', ], 'json' => [ 'query' => 'mutation ClientBuildRoute($drivers: [String], $route_name: String, $route_date: String, $service_time: Int, $pickup_time: Int, $package_processing_time: Int, $package_pickup_time: Int, $order_number: Int, $balance_mode: Int, $territory_id: Int, $order_type: String, $order_batch: String, $sorting_code: String, $label_code: String, $warehouse_id: Int, $start_address_1: Int, $end_address_1: Int, $region_group_1: Int, $start_time_1: String, $end_time_1: String, $max_distance: Int, $vehicle_type: String, $notify_at: Int, $notification_enabled: Boolean, $advance_notification_enabled: Boolean) { clientBuildRoute(drivers: $drivers, route_name: $route_name, route_date: $route_date, service_time: $service_time, pickup_time: $pickup_time, package_processing_time: $package_processing_time, package_pickup_time: $package_pickup_time, order_number: $order_number, balance_mode: $balance_mode, territory_id: $territory_id, order_type: $order_type, order_batch: $order_batch, sorting_code: $sorting_code, label_code: $label_code, warehouse_id: $warehouse_id, start_address_1: $start_address_1, end_address_1: $end_address_1, region_group_1: $region_group_1, start_time_1: $start_time_1, end_time_1: $end_time_1, max_distance: $max_distance, vehicle_type: $vehicle_type, notify_at: $notify_at, notification_enabled: $notification_enabled, advance_notification_enabled: $advance_notification_enabled) }', 'variables' => json_decode('{"drivers":["example"],"route_name":"example","route_date":"2026-01-01","service_time":1,"pickup_time":1,"package_processing_time":1,"package_pickup_time":1,"order_number":1,"balance_mode":1,"territory_id":1,"order_type":"example","order_batch":"example","sorting_code":"example","label_code":"example","warehouse_id":1,"start_address_1":1,"end_address_1":1,"region_group_1":1,"start_time_1":"example","end_time_1":"example","max_distance":1,"vehicle_type":"example","notify_at":1,"notification_enabled":true,"advance_notification_enabled":true}', true), ], ]); $data = json_decode($response->getBody(), true); print_r($data);

import requests response = requests.post( 'https://api.superlabel.ca/api/graphql', headers={ 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, json={ 'query': 'mutation ClientBuildRoute($drivers: [String], $route_name: String, $route_date: String, $service_time: Int, $pickup_time: Int, $package_processing_time: Int, $package_pickup_time: Int, $order_number: Int, $balance_mode: Int, $territory_id: Int, $order_type: String, $order_batch: String, $sorting_code: String, $label_code: String, $warehouse_id: Int, $start_address_1: Int, $end_address_1: Int, $region_group_1: Int, $start_time_1: String, $end_time_1: String, $max_distance: Int, $vehicle_type: String, $notify_at: Int, $notification_enabled: Boolean, $advance_notification_enabled: Boolean) { clientBuildRoute(drivers: $drivers, route_name: $route_name, route_date: $route_date, service_time: $service_time, pickup_time: $pickup_time, package_processing_time: $package_processing_time, package_pickup_time: $package_pickup_time, order_number: $order_number, balance_mode: $balance_mode, territory_id: $territory_id, order_type: $order_type, order_batch: $order_batch, sorting_code: $sorting_code, label_code: $label_code, warehouse_id: $warehouse_id, start_address_1: $start_address_1, end_address_1: $end_address_1, region_group_1: $region_group_1, start_time_1: $start_time_1, end_time_1: $end_time_1, max_distance: $max_distance, vehicle_type: $vehicle_type, notify_at: $notify_at, notification_enabled: $notification_enabled, advance_notification_enabled: $advance_notification_enabled) }', 'variables': {"drivers":["example"],"route_name":"example","route_date":"2026-01-01","service_time":1,"pickup_time":1,"package_processing_time":1,"package_pickup_time":1,"order_number":1,"balance_mode":1,"territory_id":1,"order_type":"example","order_batch":"example","sorting_code":"example","label_code":"example","warehouse_id":1,"start_address_1":1,"end_address_1":1,"region_group_1":1,"start_time_1":"example","end_time_1":"example","max_distance":1,"vehicle_type":"example","notify_at":1,"notification_enabled":true,"advance_notification_enabled":true}, }, ) data = response.json() print(data)

package main import ( "bytes" "encoding/json" "fmt" "io" "net/http" ) func main() { payload, _ := json.Marshal(map[string]interface{}{ "query": `mutation ClientBuildRoute($drivers: [String], $route_name: String, $route_date: String, $service_time: Int, $pickup_time: Int, $package_processing_time: Int, $package_pickup_time: Int, $order_number: Int, $balance_mode: Int, $territory_id: Int, $order_type: String, $order_batch: String, $sorting_code: String, $label_code: String, $warehouse_id: Int, $start_address_1: Int, $end_address_1: Int, $region_group_1: Int, $start_time_1: String, $end_time_1: String, $max_distance: Int, $vehicle_type: String, $notify_at: Int, $notification_enabled: Boolean, $advance_notification_enabled: Boolean) { clientBuildRoute(drivers: $drivers, route_name: $route_name, route_date: $route_date, service_time: $service_time, pickup_time: $pickup_time, package_processing_time: $package_processing_time, package_pickup_time: $package_pickup_time, order_number: $order_number, balance_mode: $balance_mode, territory_id: $territory_id, order_type: $order_type, order_batch: $order_batch, sorting_code: $sorting_code, label_code: $label_code, warehouse_id: $warehouse_id, start_address_1: $start_address_1, end_address_1: $end_address_1, region_group_1: $region_group_1, start_time_1: $start_time_1, end_time_1: $end_time_1, max_distance: $max_distance, vehicle_type: $vehicle_type, notify_at: $notify_at, notification_enabled: $notification_enabled, advance_notification_enabled: $advance_notification_enabled) }`, "variables": {"drivers":["example"],"route_name":"example","route_date":"2026-01-01","service_time":1,"pickup_time":1,"package_processing_time":1,"package_pickup_time":1,"order_number":1,"balance_mode":1,"territory_id":1,"order_type":"example","order_batch":"example","sorting_code":"example","label_code":"example","warehouse_id":1,"start_address_1":1,"end_address_1":1,"region_group_1":1,"start_time_1":"example","end_time_1":"example","max_distance":1,"vehicle_type":"example","notify_at":1,"notification_enabled":true,"advance_notification_enabled":true}, }) req, _ := http.NewRequest("POST", "https://api.superlabel.ca/api/graphql", bytes.NewBuffer(payload)) req.Header.Set("Content-Type", "application/json") req.Header.Set("Accept", "application/json") req.Header.Set("Authorization", "Bearer YOUR_TOKEN") client := &http.Client{} resp, _ := client.Do(req) defer resp.Body.Close() body, _ := io.ReadAll(resp.Body) fmt.Println(string(body)) }

const response = await fetch('https://api.superlabel.ca/api/graphql', { method: 'POST', headers: { 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, body: JSON.stringify({ query: `mutation ClientBuildRoute($drivers: [String], $route_name: String, $route_date: String, $service_time: Int, $pickup_time: Int, $package_processing_time: Int, $package_pickup_time: Int, $order_number: Int, $balance_mode: Int, $territory_id: Int, $order_type: String, $order_batch: String, $sorting_code: String, $label_code: String, $warehouse_id: Int, $start_address_1: Int, $end_address_1: Int, $region_group_1: Int, $start_time_1: String, $end_time_1: String, $max_distance: Int, $vehicle_type: String, $notify_at: Int, $notification_enabled: Boolean, $advance_notification_enabled: Boolean) { clientBuildRoute(drivers: $drivers, route_name: $route_name, route_date: $route_date, service_time: $service_time, pickup_time: $pickup_time, package_processing_time: $package_processing_time, package_pickup_time: $package_pickup_time, order_number: $order_number, balance_mode: $balance_mode, territory_id: $territory_id, order_type: $order_type, order_batch: $order_batch, sorting_code: $sorting_code, label_code: $label_code, warehouse_id: $warehouse_id, start_address_1: $start_address_1, end_address_1: $end_address_1, region_group_1: $region_group_1, start_time_1: $start_time_1, end_time_1: $end_time_1, max_distance: $max_distance, vehicle_type: $vehicle_type, notify_at: $notify_at, notification_enabled: $notification_enabled, advance_notification_enabled: $advance_notification_enabled) }`, variables: { "drivers": [ "example" ], "route_name": "example", "route_date": "2026-01-01", "service_time": 1, "pickup_time": 1, "package_processing_time": 1, "package_pickup_time": 1, "order_number": 1, "balance_mode": 1, "territory_id": 1, "order_type": "example", "order_batch": "example", "sorting_code": "example", "label_code": "example", "warehouse_id": 1, "start_address_1": 1, "end_address_1": 1, "region_group_1": 1, "start_time_1": "example", "end_time_1": "example", "max_distance": 1, "vehicle_type": "example", "notify_at": 1, "notification_enabled": true, "advance_notification_enabled": true }, }), }); const data = await response.json(); console.log(data);

import java.net.http.*; import java.net.URI; HttpClient client = HttpClient.newHttpClient(); String body = "{\"query\":\"mutation ClientBuildRoute($drivers: [String], $route_name: String, $route_date: String, $service_time: Int, $pickup_time: Int, $package_processing_time: Int, $package_pickup_time: Int, $order_number: Int, $balance_mode: Int, $territory_id: Int, $order_type: String, $order_batch: String, $sorting_code: String, $label_code: String, $warehouse_id: Int, $start_address_1: Int, $end_address_1: Int, $region_group_1: Int, $start_time_1: String, $end_time_1: String, $max_distance: Int, $vehicle_type: String, $notify_at: Int, $notification_enabled: Boolean, $advance_notification_enabled: Boolean) {\\n clientBuildRoute(drivers: $drivers, route_name: $route_name, route_date: $route_date, service_time: $service_time, pickup_time: $pickup_time, package_processing_time: $package_processing_time, package_pickup_time: $package_pickup_time, order_number: $order_number, balance_mode: $balance_mode, territory_id: $territory_id, order_type: $order_type, order_batch: $order_batch, sorting_code: $sorting_code, label_code: $label_code, warehouse_id: $warehouse_id, start_address_1: $start_address_1, end_address_1: $end_address_1, region_group_1: $region_group_1, start_time_1: $start_time_1, end_time_1: $end_time_1, max_distance: $max_distance, vehicle_type: $vehicle_type, notify_at: $notify_at, notification_enabled: $notification_enabled, advance_notification_enabled: $advance_notification_enabled)\\n}\",\"variables\":{\"drivers\":[\"example\"],\"route_name\":\"example\",\"route_date\":\"2026-01-01\",\"service_time\":1,\"pickup_time\":1,\"package_processing_time\":1,\"package_pickup_time\":1,\"order_number\":1,\"balance_mode\":1,\"territory_id\":1,\"order_type\":\"example\",\"order_batch\":\"example\",\"sorting_code\":\"example\",\"label_code\":\"example\",\"warehouse_id\":1,\"start_address_1\":1,\"end_address_1\":1,\"region_group_1\":1,\"start_time_1\":\"example\",\"end_time_1\":\"example\",\"max_distance\":1,\"vehicle_type\":\"example\",\"notify_at\":1,\"notification_enabled\":true,\"advance_notification_enabled\":true}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.superlabel.ca/api/graphql")) .header("Content-Type", "application/json") .header("Accept", "application/json") .header("Authorization", "Bearer YOUR_TOKEN") .POST(HttpRequest.BodyPublishers.ofString(body)) .build(); HttpResponse<String> response = client.send( request, HttpResponse.BodyHandlers.ofString() ); System.out.println(response.body());

require 'net/http' require 'json' require 'uri' uri = URI.parse('https://api.superlabel.ca/api/graphql') http = Net::HTTP.new(uri.host, uri.port) http.use_ssl = uri.scheme == 'https' request = Net::HTTP::Post.new(uri) request.content_type = 'application/json' request['Accept'] = 'application/json' request['Authorization'] = 'Bearer YOUR_TOKEN' request.body = JSON.dump({ query: 'mutation ClientBuildRoute($drivers: [String], $route_name: String, $route_date: String, $service_time: Int, $pickup_time: Int, $package_processing_time: Int, $package_pickup_time: Int, $order_number: Int, $balance_mode: Int, $territory_id: Int, $order_type: String, $order_batch: String, $sorting_code: String, $label_code: String, $warehouse_id: Int, $start_address_1: Int, $end_address_1: Int, $region_group_1: Int, $start_time_1: String, $end_time_1: String, $max_distance: Int, $vehicle_type: String, $notify_at: Int, $notification_enabled: Boolean, $advance_notification_enabled: Boolean) { clientBuildRoute(drivers: $drivers, route_name: $route_name, route_date: $route_date, service_time: $service_time, pickup_time: $pickup_time, package_processing_time: $package_processing_time, package_pickup_time: $package_pickup_time, order_number: $order_number, balance_mode: $balance_mode, territory_id: $territory_id, order_type: $order_type, order_batch: $order_batch, sorting_code: $sorting_code, label_code: $label_code, warehouse_id: $warehouse_id, start_address_1: $start_address_1, end_address_1: $end_address_1, region_group_1: $region_group_1, start_time_1: $start_time_1, end_time_1: $end_time_1, max_distance: $max_distance, vehicle_type: $vehicle_type, notify_at: $notify_at, notification_enabled: $notification_enabled, advance_notification_enabled: $advance_notification_enabled) }', variables: {"drivers":["example"],"route_name":"example","route_date":"2026-01-01","service_time":1,"pickup_time":1,"package_processing_time":1,"package_pickup_time":1,"order_number":1,"balance_mode":1,"territory_id":1,"order_type":"example","order_batch":"example","sorting_code":"example","label_code":"example","warehouse_id":1,"start_address_1":1,"end_address_1":1,"region_group_1":1,"start_time_1":"example","end_time_1":"example","max_distance":1,"vehicle_type":"example","notify_at":1,"notification_enabled":true,"advance_notification_enabled":true} }) response = http.request(request) puts JSON.parse(response.body)

<?php require 'vendor/autoload.php'; $client = new GuzzleHttp\Client(); $response = $client->post('https://api.superlabel.ca/api/graphql', [ 'headers' => [ 'Content-Type' => 'application/json', 'Accept' => 'application/json', 'Authorization' => 'Bearer YOUR_TOKEN', ], 'json' => [ 'query' => 'mutation ClientBuildRouteV2($drivers: [String], $route_date: String, $route_name: String, $balance_mode: String, $serve_time: Int, $service_time: Int, $package_processing_time: Int, $pickup_time: Int, $package_pickup_time: Int, $order_type: String, $order_batch: String, $sorting_code: String, $territory_id: Int, $label_code: String, $warehouse_id: Int, $max_distance: Float, $need_approval: Int, $notify_at: Int, $notification_enabled: Boolean, $advance_notification_enabled: Boolean) { clientBuildRouteV2(drivers: $drivers, route_date: $route_date, route_name: $route_name, balance_mode: $balance_mode, serve_time: $serve_time, service_time: $service_time, package_processing_time: $package_processing_time, pickup_time: $pickup_time, package_pickup_time: $package_pickup_time, order_type: $order_type, order_batch: $order_batch, sorting_code: $sorting_code, territory_id: $territory_id, label_code: $label_code, warehouse_id: $warehouse_id, max_distance: $max_distance, need_approval: $need_approval, notify_at: $notify_at, notification_enabled: $notification_enabled, advance_notification_enabled: $advance_notification_enabled) }', 'variables' => json_decode('{"drivers":["example"],"route_date":"2026-01-01","route_name":"example","balance_mode":"example","serve_time":1,"service_time":1,"package_processing_time":1,"pickup_time":1,"package_pickup_time":1,"order_type":"example","order_batch":"example","sorting_code":"example","territory_id":1,"label_code":"example","warehouse_id":1,"max_distance":1.5,"need_approval":1,"notify_at":1,"notification_enabled":true,"advance_notification_enabled":true}', true), ], ]); $data = json_decode($response->getBody(), true); print_r($data);

import requests response = requests.post( 'https://api.superlabel.ca/api/graphql', headers={ 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, json={ 'query': 'mutation ClientBuildRouteV2($drivers: [String], $route_date: String, $route_name: String, $balance_mode: String, $serve_time: Int, $service_time: Int, $package_processing_time: Int, $pickup_time: Int, $package_pickup_time: Int, $order_type: String, $order_batch: String, $sorting_code: String, $territory_id: Int, $label_code: String, $warehouse_id: Int, $max_distance: Float, $need_approval: Int, $notify_at: Int, $notification_enabled: Boolean, $advance_notification_enabled: Boolean) { clientBuildRouteV2(drivers: $drivers, route_date: $route_date, route_name: $route_name, balance_mode: $balance_mode, serve_time: $serve_time, service_time: $service_time, package_processing_time: $package_processing_time, pickup_time: $pickup_time, package_pickup_time: $package_pickup_time, order_type: $order_type, order_batch: $order_batch, sorting_code: $sorting_code, territory_id: $territory_id, label_code: $label_code, warehouse_id: $warehouse_id, max_distance: $max_distance, need_approval: $need_approval, notify_at: $notify_at, notification_enabled: $notification_enabled, advance_notification_enabled: $advance_notification_enabled) }', 'variables': {"drivers":["example"],"route_date":"2026-01-01","route_name":"example","balance_mode":"example","serve_time":1,"service_time":1,"package_processing_time":1,"pickup_time":1,"package_pickup_time":1,"order_type":"example","order_batch":"example","sorting_code":"example","territory_id":1,"label_code":"example","warehouse_id":1,"max_distance":1.5,"need_approval":1,"notify_at":1,"notification_enabled":true,"advance_notification_enabled":true}, }, ) data = response.json() print(data)

package main import ( "bytes" "encoding/json" "fmt" "io" "net/http" ) func main() { payload, _ := json.Marshal(map[string]interface{}{ "query": `mutation ClientBuildRouteV2($drivers: [String], $route_date: String, $route_name: String, $balance_mode: String, $serve_time: Int, $service_time: Int, $package_processing_time: Int, $pickup_time: Int, $package_pickup_time: Int, $order_type: String, $order_batch: String, $sorting_code: String, $territory_id: Int, $label_code: String, $warehouse_id: Int, $max_distance: Float, $need_approval: Int, $notify_at: Int, $notification_enabled: Boolean, $advance_notification_enabled: Boolean) { clientBuildRouteV2(drivers: $drivers, route_date: $route_date, route_name: $route_name, balance_mode: $balance_mode, serve_time: $serve_time, service_time: $service_time, package_processing_time: $package_processing_time, pickup_time: $pickup_time, package_pickup_time: $package_pickup_time, order_type: $order_type, order_batch: $order_batch, sorting_code: $sorting_code, territory_id: $territory_id, label_code: $label_code, warehouse_id: $warehouse_id, max_distance: $max_distance, need_approval: $need_approval, notify_at: $notify_at, notification_enabled: $notification_enabled, advance_notification_enabled: $advance_notification_enabled) }`, "variables": {"drivers":["example"],"route_date":"2026-01-01","route_name":"example","balance_mode":"example","serve_time":1,"service_time":1,"package_processing_time":1,"pickup_time":1,"package_pickup_time":1,"order_type":"example","order_batch":"example","sorting_code":"example","territory_id":1,"label_code":"example","warehouse_id":1,"max_distance":1.5,"need_approval":1,"notify_at":1,"notification_enabled":true,"advance_notification_enabled":true}, }) req, _ := http.NewRequest("POST", "https://api.superlabel.ca/api/graphql", bytes.NewBuffer(payload)) req.Header.Set("Content-Type", "application/json") req.Header.Set("Accept", "application/json") req.Header.Set("Authorization", "Bearer YOUR_TOKEN") client := &http.Client{} resp, _ := client.Do(req) defer resp.Body.Close() body, _ := io.ReadAll(resp.Body) fmt.Println(string(body)) }

const response = await fetch('https://api.superlabel.ca/api/graphql', { method: 'POST', headers: { 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, body: JSON.stringify({ query: `mutation ClientBuildRouteV2($drivers: [String], $route_date: String, $route_name: String, $balance_mode: String, $serve_time: Int, $service_time: Int, $package_processing_time: Int, $pickup_time: Int, $package_pickup_time: Int, $order_type: String, $order_batch: String, $sorting_code: String, $territory_id: Int, $label_code: String, $warehouse_id: Int, $max_distance: Float, $need_approval: Int, $notify_at: Int, $notification_enabled: Boolean, $advance_notification_enabled: Boolean) { clientBuildRouteV2(drivers: $drivers, route_date: $route_date, route_name: $route_name, balance_mode: $balance_mode, serve_time: $serve_time, service_time: $service_time, package_processing_time: $package_processing_time, pickup_time: $pickup_time, package_pickup_time: $package_pickup_time, order_type: $order_type, order_batch: $order_batch, sorting_code: $sorting_code, territory_id: $territory_id, label_code: $label_code, warehouse_id: $warehouse_id, max_distance: $max_distance, need_approval: $need_approval, notify_at: $notify_at, notification_enabled: $notification_enabled, advance_notification_enabled: $advance_notification_enabled) }`, variables: { "drivers": [ "example" ], "route_date": "2026-01-01", "route_name": "example", "balance_mode": "example", "serve_time": 1, "service_time": 1, "package_processing_time": 1, "pickup_time": 1, "package_pickup_time": 1, "order_type": "example", "order_batch": "example", "sorting_code": "example", "territory_id": 1, "label_code": "example", "warehouse_id": 1, "max_distance": 1.5, "need_approval": 1, "notify_at": 1, "notification_enabled": true, "advance_notification_enabled": true }, }), }); const data = await response.json(); console.log(data);

import java.net.http.*; import java.net.URI; HttpClient client = HttpClient.newHttpClient(); String body = "{\"query\":\"mutation ClientBuildRouteV2($drivers: [String], $route_date: String, $route_name: String, $balance_mode: String, $serve_time: Int, $service_time: Int, $package_processing_time: Int, $pickup_time: Int, $package_pickup_time: Int, $order_type: String, $order_batch: String, $sorting_code: String, $territory_id: Int, $label_code: String, $warehouse_id: Int, $max_distance: Float, $need_approval: Int, $notify_at: Int, $notification_enabled: Boolean, $advance_notification_enabled: Boolean) {\\n clientBuildRouteV2(drivers: $drivers, route_date: $route_date, route_name: $route_name, balance_mode: $balance_mode, serve_time: $serve_time, service_time: $service_time, package_processing_time: $package_processing_time, pickup_time: $pickup_time, package_pickup_time: $package_pickup_time, order_type: $order_type, order_batch: $order_batch, sorting_code: $sorting_code, territory_id: $territory_id, label_code: $label_code, warehouse_id: $warehouse_id, max_distance: $max_distance, need_approval: $need_approval, notify_at: $notify_at, notification_enabled: $notification_enabled, advance_notification_enabled: $advance_notification_enabled)\\n}\",\"variables\":{\"drivers\":[\"example\"],\"route_date\":\"2026-01-01\",\"route_name\":\"example\",\"balance_mode\":\"example\",\"serve_time\":1,\"service_time\":1,\"package_processing_time\":1,\"pickup_time\":1,\"package_pickup_time\":1,\"order_type\":\"example\",\"order_batch\":\"example\",\"sorting_code\":\"example\",\"territory_id\":1,\"label_code\":\"example\",\"warehouse_id\":1,\"max_distance\":1.5,\"need_approval\":1,\"notify_at\":1,\"notification_enabled\":true,\"advance_notification_enabled\":true}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.superlabel.ca/api/graphql")) .header("Content-Type", "application/json") .header("Accept", "application/json") .header("Authorization", "Bearer YOUR_TOKEN") .POST(HttpRequest.BodyPublishers.ofString(body)) .build(); HttpResponse<String> response = client.send( request, HttpResponse.BodyHandlers.ofString() ); System.out.println(response.body());

require 'net/http' require 'json' require 'uri' uri = URI.parse('https://api.superlabel.ca/api/graphql') http = Net::HTTP.new(uri.host, uri.port) http.use_ssl = uri.scheme == 'https' request = Net::HTTP::Post.new(uri) request.content_type = 'application/json' request['Accept'] = 'application/json' request['Authorization'] = 'Bearer YOUR_TOKEN' request.body = JSON.dump({ query: 'mutation ClientBuildRouteV2($drivers: [String], $route_date: String, $route_name: String, $balance_mode: String, $serve_time: Int, $service_time: Int, $package_processing_time: Int, $pickup_time: Int, $package_pickup_time: Int, $order_type: String, $order_batch: String, $sorting_code: String, $territory_id: Int, $label_code: String, $warehouse_id: Int, $max_distance: Float, $need_approval: Int, $notify_at: Int, $notification_enabled: Boolean, $advance_notification_enabled: Boolean) { clientBuildRouteV2(drivers: $drivers, route_date: $route_date, route_name: $route_name, balance_mode: $balance_mode, serve_time: $serve_time, service_time: $service_time, package_processing_time: $package_processing_time, pickup_time: $pickup_time, package_pickup_time: $package_pickup_time, order_type: $order_type, order_batch: $order_batch, sorting_code: $sorting_code, territory_id: $territory_id, label_code: $label_code, warehouse_id: $warehouse_id, max_distance: $max_distance, need_approval: $need_approval, notify_at: $notify_at, notification_enabled: $notification_enabled, advance_notification_enabled: $advance_notification_enabled) }', variables: {"drivers":["example"],"route_date":"2026-01-01","route_name":"example","balance_mode":"example","serve_time":1,"service_time":1,"package_processing_time":1,"pickup_time":1,"package_pickup_time":1,"order_type":"example","order_batch":"example","sorting_code":"example","territory_id":1,"label_code":"example","warehouse_id":1,"max_distance":1.5,"need_approval":1,"notify_at":1,"notification_enabled":true,"advance_notification_enabled":true} }) response = http.request(request) puts JSON.parse(response.body)

<?php require 'vendor/autoload.php'; $client = new GuzzleHttp\Client(); $response = $client->post('https://api.superlabel.ca/api/graphql', [ 'headers' => [ 'Content-Type' => 'application/json', 'Accept' => 'application/json', 'Authorization' => 'Bearer YOUR_TOKEN', ], 'json' => [ 'query' => 'mutation ClientBuildRouteV3($route_name: String!, $route_date: String!, $routing_engine: Int, $balance_mode: String, $capacity_type: Int, $service_time: Int, $package_processing_time: Int, $pickup_time: Int, $package_pickup_time: Int, $order_number: Int, $need_approval: Int, $territory_id: Int, $order_batch: String, $sorting_code: String, $label_code: String, $warehouse_id: Int, $max_distance: Float, $order_type: String, $related_order_type: String, $order_source: String, $drivers: [String]!, $notify_at: Int, $notification_enabled: Boolean, $advance_notification_enabled: Boolean) { clientBuildRouteV3(route_name: $route_name, route_date: $route_date, routing_engine: $routing_engine, balance_mode: $balance_mode, capacity_type: $capacity_type, service_time: $service_time, package_processing_time: $package_processing_time, pickup_time: $pickup_time, package_pickup_time: $package_pickup_time, order_number: $order_number, need_approval: $need_approval, territory_id: $territory_id, order_batch: $order_batch, sorting_code: $sorting_code, label_code: $label_code, warehouse_id: $warehouse_id, max_distance: $max_distance, order_type: $order_type, related_order_type: $related_order_type, order_source: $order_source, drivers: $drivers, notify_at: $notify_at, notification_enabled: $notification_enabled, advance_notification_enabled: $advance_notification_enabled) }', 'variables' => json_decode('{"route_name":"example","route_date":"2026-01-01","routing_engine":1,"balance_mode":"example","capacity_type":1,"service_time":1,"package_processing_time":1,"pickup_time":1,"package_pickup_time":1,"order_number":1,"need_approval":1,"territory_id":1,"order_batch":"example","sorting_code":"example","label_code":"example","warehouse_id":1,"max_distance":1.5,"order_type":"example","related_order_type":"example","order_source":"example","drivers":["example"],"notify_at":1,"notification_enabled":true,"advance_notification_enabled":true}', true), ], ]); $data = json_decode($response->getBody(), true); print_r($data);

import requests response = requests.post( 'https://api.superlabel.ca/api/graphql', headers={ 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, json={ 'query': 'mutation ClientBuildRouteV3($route_name: String!, $route_date: String!, $routing_engine: Int, $balance_mode: String, $capacity_type: Int, $service_time: Int, $package_processing_time: Int, $pickup_time: Int, $package_pickup_time: Int, $order_number: Int, $need_approval: Int, $territory_id: Int, $order_batch: String, $sorting_code: String, $label_code: String, $warehouse_id: Int, $max_distance: Float, $order_type: String, $related_order_type: String, $order_source: String, $drivers: [String]!, $notify_at: Int, $notification_enabled: Boolean, $advance_notification_enabled: Boolean) { clientBuildRouteV3(route_name: $route_name, route_date: $route_date, routing_engine: $routing_engine, balance_mode: $balance_mode, capacity_type: $capacity_type, service_time: $service_time, package_processing_time: $package_processing_time, pickup_time: $pickup_time, package_pickup_time: $package_pickup_time, order_number: $order_number, need_approval: $need_approval, territory_id: $territory_id, order_batch: $order_batch, sorting_code: $sorting_code, label_code: $label_code, warehouse_id: $warehouse_id, max_distance: $max_distance, order_type: $order_type, related_order_type: $related_order_type, order_source: $order_source, drivers: $drivers, notify_at: $notify_at, notification_enabled: $notification_enabled, advance_notification_enabled: $advance_notification_enabled) }', 'variables': {"route_name":"example","route_date":"2026-01-01","routing_engine":1,"balance_mode":"example","capacity_type":1,"service_time":1,"package_processing_time":1,"pickup_time":1,"package_pickup_time":1,"order_number":1,"need_approval":1,"territory_id":1,"order_batch":"example","sorting_code":"example","label_code":"example","warehouse_id":1,"max_distance":1.5,"order_type":"example","related_order_type":"example","order_source":"example","drivers":["example"],"notify_at":1,"notification_enabled":true,"advance_notification_enabled":true}, }, ) data = response.json() print(data)

package main import ( "bytes" "encoding/json" "fmt" "io" "net/http" ) func main() { payload, _ := json.Marshal(map[string]interface{}{ "query": `mutation ClientBuildRouteV3($route_name: String!, $route_date: String!, $routing_engine: Int, $balance_mode: String, $capacity_type: Int, $service_time: Int, $package_processing_time: Int, $pickup_time: Int, $package_pickup_time: Int, $order_number: Int, $need_approval: Int, $territory_id: Int, $order_batch: String, $sorting_code: String, $label_code: String, $warehouse_id: Int, $max_distance: Float, $order_type: String, $related_order_type: String, $order_source: String, $drivers: [String]!, $notify_at: Int, $notification_enabled: Boolean, $advance_notification_enabled: Boolean) { clientBuildRouteV3(route_name: $route_name, route_date: $route_date, routing_engine: $routing_engine, balance_mode: $balance_mode, capacity_type: $capacity_type, service_time: $service_time, package_processing_time: $package_processing_time, pickup_time: $pickup_time, package_pickup_time: $package_pickup_time, order_number: $order_number, need_approval: $need_approval, territory_id: $territory_id, order_batch: $order_batch, sorting_code: $sorting_code, label_code: $label_code, warehouse_id: $warehouse_id, max_distance: $max_distance, order_type: $order_type, related_order_type: $related_order_type, order_source: $order_source, drivers: $drivers, notify_at: $notify_at, notification_enabled: $notification_enabled, advance_notification_enabled: $advance_notification_enabled) }`, "variables": {"route_name":"example","route_date":"2026-01-01","routing_engine":1,"balance_mode":"example","capacity_type":1,"service_time":1,"package_processing_time":1,"pickup_time":1,"package_pickup_time":1,"order_number":1,"need_approval":1,"territory_id":1,"order_batch":"example","sorting_code":"example","label_code":"example","warehouse_id":1,"max_distance":1.5,"order_type":"example","related_order_type":"example","order_source":"example","drivers":["example"],"notify_at":1,"notification_enabled":true,"advance_notification_enabled":true}, }) req, _ := http.NewRequest("POST", "https://api.superlabel.ca/api/graphql", bytes.NewBuffer(payload)) req.Header.Set("Content-Type", "application/json") req.Header.Set("Accept", "application/json") req.Header.Set("Authorization", "Bearer YOUR_TOKEN") client := &http.Client{} resp, _ := client.Do(req) defer resp.Body.Close() body, _ := io.ReadAll(resp.Body) fmt.Println(string(body)) }

const response = await fetch('https://api.superlabel.ca/api/graphql', { method: 'POST', headers: { 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, body: JSON.stringify({ query: `mutation ClientBuildRouteV3($route_name: String!, $route_date: String!, $routing_engine: Int, $balance_mode: String, $capacity_type: Int, $service_time: Int, $package_processing_time: Int, $pickup_time: Int, $package_pickup_time: Int, $order_number: Int, $need_approval: Int, $territory_id: Int, $order_batch: String, $sorting_code: String, $label_code: String, $warehouse_id: Int, $max_distance: Float, $order_type: String, $related_order_type: String, $order_source: String, $drivers: [String]!, $notify_at: Int, $notification_enabled: Boolean, $advance_notification_enabled: Boolean) { clientBuildRouteV3(route_name: $route_name, route_date: $route_date, routing_engine: $routing_engine, balance_mode: $balance_mode, capacity_type: $capacity_type, service_time: $service_time, package_processing_time: $package_processing_time, pickup_time: $pickup_time, package_pickup_time: $package_pickup_time, order_number: $order_number, need_approval: $need_approval, territory_id: $territory_id, order_batch: $order_batch, sorting_code: $sorting_code, label_code: $label_code, warehouse_id: $warehouse_id, max_distance: $max_distance, order_type: $order_type, related_order_type: $related_order_type, order_source: $order_source, drivers: $drivers, notify_at: $notify_at, notification_enabled: $notification_enabled, advance_notification_enabled: $advance_notification_enabled) }`, variables: { "route_name": "example", "route_date": "2026-01-01", "routing_engine": 1, "balance_mode": "example", "capacity_type": 1, "service_time": 1, "package_processing_time": 1, "pickup_time": 1, "package_pickup_time": 1, "order_number": 1, "need_approval": 1, "territory_id": 1, "order_batch": "example", "sorting_code": "example", "label_code": "example", "warehouse_id": 1, "max_distance": 1.5, "order_type": "example", "related_order_type": "example", "order_source": "example", "drivers": [ "example" ], "notify_at": 1, "notification_enabled": true, "advance_notification_enabled": true }, }), }); const data = await response.json(); console.log(data);

import java.net.http.*; import java.net.URI; HttpClient client = HttpClient.newHttpClient(); String body = "{\"query\":\"mutation ClientBuildRouteV3($route_name: String!, $route_date: String!, $routing_engine: Int, $balance_mode: String, $capacity_type: Int, $service_time: Int, $package_processing_time: Int, $pickup_time: Int, $package_pickup_time: Int, $order_number: Int, $need_approval: Int, $territory_id: Int, $order_batch: String, $sorting_code: String, $label_code: String, $warehouse_id: Int, $max_distance: Float, $order_type: String, $related_order_type: String, $order_source: String, $drivers: [String]!, $notify_at: Int, $notification_enabled: Boolean, $advance_notification_enabled: Boolean) {\\n clientBuildRouteV3(route_name: $route_name, route_date: $route_date, routing_engine: $routing_engine, balance_mode: $balance_mode, capacity_type: $capacity_type, service_time: $service_time, package_processing_time: $package_processing_time, pickup_time: $pickup_time, package_pickup_time: $package_pickup_time, order_number: $order_number, need_approval: $need_approval, territory_id: $territory_id, order_batch: $order_batch, sorting_code: $sorting_code, label_code: $label_code, warehouse_id: $warehouse_id, max_distance: $max_distance, order_type: $order_type, related_order_type: $related_order_type, order_source: $order_source, drivers: $drivers, notify_at: $notify_at, notification_enabled: $notification_enabled, advance_notification_enabled: $advance_notification_enabled)\\n}\",\"variables\":{\"route_name\":\"example\",\"route_date\":\"2026-01-01\",\"routing_engine\":1,\"balance_mode\":\"example\",\"capacity_type\":1,\"service_time\":1,\"package_processing_time\":1,\"pickup_time\":1,\"package_pickup_time\":1,\"order_number\":1,\"need_approval\":1,\"territory_id\":1,\"order_batch\":\"example\",\"sorting_code\":\"example\",\"label_code\":\"example\",\"warehouse_id\":1,\"max_distance\":1.5,\"order_type\":\"example\",\"related_order_type\":\"example\",\"order_source\":\"example\",\"drivers\":[\"example\"],\"notify_at\":1,\"notification_enabled\":true,\"advance_notification_enabled\":true}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.superlabel.ca/api/graphql")) .header("Content-Type", "application/json") .header("Accept", "application/json") .header("Authorization", "Bearer YOUR_TOKEN") .POST(HttpRequest.BodyPublishers.ofString(body)) .build(); HttpResponse<String> response = client.send( request, HttpResponse.BodyHandlers.ofString() ); System.out.println(response.body());

require 'net/http' require 'json' require 'uri' uri = URI.parse('https://api.superlabel.ca/api/graphql') http = Net::HTTP.new(uri.host, uri.port) http.use_ssl = uri.scheme == 'https' request = Net::HTTP::Post.new(uri) request.content_type = 'application/json' request['Accept'] = 'application/json' request['Authorization'] = 'Bearer YOUR_TOKEN' request.body = JSON.dump({ query: 'mutation ClientBuildRouteV3($route_name: String!, $route_date: String!, $routing_engine: Int, $balance_mode: String, $capacity_type: Int, $service_time: Int, $package_processing_time: Int, $pickup_time: Int, $package_pickup_time: Int, $order_number: Int, $need_approval: Int, $territory_id: Int, $order_batch: String, $sorting_code: String, $label_code: String, $warehouse_id: Int, $max_distance: Float, $order_type: String, $related_order_type: String, $order_source: String, $drivers: [String]!, $notify_at: Int, $notification_enabled: Boolean, $advance_notification_enabled: Boolean) { clientBuildRouteV3(route_name: $route_name, route_date: $route_date, routing_engine: $routing_engine, balance_mode: $balance_mode, capacity_type: $capacity_type, service_time: $service_time, package_processing_time: $package_processing_time, pickup_time: $pickup_time, package_pickup_time: $package_pickup_time, order_number: $order_number, need_approval: $need_approval, territory_id: $territory_id, order_batch: $order_batch, sorting_code: $sorting_code, label_code: $label_code, warehouse_id: $warehouse_id, max_distance: $max_distance, order_type: $order_type, related_order_type: $related_order_type, order_source: $order_source, drivers: $drivers, notify_at: $notify_at, notification_enabled: $notification_enabled, advance_notification_enabled: $advance_notification_enabled) }', variables: {"route_name":"example","route_date":"2026-01-01","routing_engine":1,"balance_mode":"example","capacity_type":1,"service_time":1,"package_processing_time":1,"pickup_time":1,"package_pickup_time":1,"order_number":1,"need_approval":1,"territory_id":1,"order_batch":"example","sorting_code":"example","label_code":"example","warehouse_id":1,"max_distance":1.5,"order_type":"example","related_order_type":"example","order_source":"example","drivers":["example"],"notify_at":1,"notification_enabled":true,"advance_notification_enabled":true} }) response = http.request(request) puts JSON.parse(response.body)

<?php require 'vendor/autoload.php'; $client = new GuzzleHttp\Client(); $response = $client->post('https://api.superlabel.ca/api/graphql', [ 'headers' => [ 'Content-Type' => 'application/json', 'Accept' => 'application/json', 'Authorization' => 'Bearer YOUR_TOKEN', ], 'json' => [ 'query' => 'mutation ClientOrderCreate($customer_id: Int, $customer_code: String, $postcode: String, $street_number: String, $street_name: String, $apt: String, $buzz_code: String, $ref: String, $order_code: String, $order_channel_code: String, $carrier_name: String, $address_1: String, $address_2: String, $combine_address: Boolean, $city: String, $province: String, $country: String, $code: String, $name: String, $company_name: String, $email: String, $telephone: String, $note: String, $pickup_instruction: String, $delivery_instruction: String, $notification_language: String, $skills: String, $latitude: Float, $longitude: Float, $signature_option: Int, $insurance_option: Int, $need_pick_up: Int, $allow_dropoff: Int, $pin_verification_required: Int, $self_pickup: Int, $auto_deduplication: Int, $service_time: Int, $pickup_service_time: Int, $pickup_date: String, $schedule_date: String, $time_window_start: String, $time_window_end: String, $pickup_time_window_start: String, $pickup_time_window_end: String, $type: String, $sorting_code: String, $a_scan_at: String, $packages: Int, $packagesDetail: [Json], $surcharges: [Json], $external_customer: Json, $fulfillment_center_code: String, $shipping_from: Int, $sender_name: String, $sender_company_name: String, $sender_email: String, $sender_telephone: String, $sender_country: String, $sender_province: String, $sender_city: String, $sender_address_1: String, $sender_address_2: String, $sender_postcode: String, $sender_address_type: String, $sender_code: String) { clientOrderCreate(customer_id: $customer_id, customer_code: $customer_code, postcode: $postcode, street_number: $street_number, street_name: $street_name, apt: $apt, buzz_code: $buzz_code, ref: $ref, order_code: $order_code, order_channel_code: $order_channel_code, carrier_name: $carrier_name, address_1: $address_1, address_2: $address_2, combine_address: $combine_address, city: $city, province: $province, country: $country, code: $code, name: $name, company_name: $company_name, email: $email, telephone: $telephone, note: $note, pickup_instruction: $pickup_instruction, delivery_instruction: $delivery_instruction, notification_language: $notification_language, skills: $skills, latitude: $latitude, longitude: $longitude, signature_option: $signature_option, insurance_option: $insurance_option, need_pick_up: $need_pick_up, allow_dropoff: $allow_dropoff, pin_verification_required: $pin_verification_required, self_pickup: $self_pickup, auto_deduplication: $auto_deduplication, service_time: $service_time, pickup_service_time: $pickup_service_time, pickup_date: $pickup_date, schedule_date: $schedule_date, time_window_start: $time_window_start, time_window_end: $time_window_end, pickup_time_window_start: $pickup_time_window_start, pickup_time_window_end: $pickup_time_window_end, type: $type, sorting_code: $sorting_code, a_scan_at: $a_scan_at, packages: $packages, packagesDetail: $packagesDetail, surcharges: $surcharges, external_customer: $external_customer, fulfillment_center_code: $fulfillment_center_code, shipping_from: $shipping_from, sender_name: $sender_name, sender_company_name: $sender_company_name, sender_email: $sender_email, sender_telephone: $sender_telephone, sender_country: $sender_country, sender_province: $sender_province, sender_city: $sender_city, sender_address_1: $sender_address_1, sender_address_2: $sender_address_2, sender_postcode: $sender_postcode, sender_address_type: $sender_address_type, sender_code: $sender_code) }', 'variables' => json_decode('{"customer_id":1,"customer_code":"example","postcode":"M5V 2T6","street_number":"example","street_name":"example","apt":"example","buzz_code":"example","ref":"example","order_code":"example","order_channel_code":"example","carrier_name":"example","address_1":"example","address_2":"example","combine_address":true,"city":"Toronto","province":"ON","country":"CA","code":"example","name":"example","company_name":"example","email":"user@example.com","telephone":"+14165551234","note":"example","pickup_instruction":"example","delivery_instruction":"example","notification_language":"example","skills":"example","latitude":1.5,"longitude":1.5,"signature_option":1,"insurance_option":1,"need_pick_up":1,"allow_dropoff":1,"pin_verification_required":1,"self_pickup":1,"auto_deduplication":1,"service_time":1,"pickup_service_time":1,"pickup_date":"2026-01-01","schedule_date":"2026-01-01","time_window_start":"example","time_window_end":"example","pickup_time_window_start":"example","pickup_time_window_end":"example","type":"example","sorting_code":"example","a_scan_at":"2026-01-01","packages":1,"packagesDetail":[{"key":"value"}],"surcharges":[{"key":"value"}],"external_customer":{"key":"value"},"fulfillment_center_code":"example","shipping_from":1,"sender_name":"example","sender_company_name":"example","sender_email":"user@example.com","sender_telephone":"+14165551234","sender_country":"CA","sender_province":"ON","sender_city":"Toronto","sender_address_1":"example","sender_address_2":"example","sender_postcode":"M5V 2T6","sender_address_type":"example","sender_code":"example"}', true), ], ]); $data = json_decode($response->getBody(), true); print_r($data);

import requests response = requests.post( 'https://api.superlabel.ca/api/graphql', headers={ 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, json={ 'query': 'mutation ClientOrderCreate($customer_id: Int, $customer_code: String, $postcode: String, $street_number: String, $street_name: String, $apt: String, $buzz_code: String, $ref: String, $order_code: String, $order_channel_code: String, $carrier_name: String, $address_1: String, $address_2: String, $combine_address: Boolean, $city: String, $province: String, $country: String, $code: String, $name: String, $company_name: String, $email: String, $telephone: String, $note: String, $pickup_instruction: String, $delivery_instruction: String, $notification_language: String, $skills: String, $latitude: Float, $longitude: Float, $signature_option: Int, $insurance_option: Int, $need_pick_up: Int, $allow_dropoff: Int, $pin_verification_required: Int, $self_pickup: Int, $auto_deduplication: Int, $service_time: Int, $pickup_service_time: Int, $pickup_date: String, $schedule_date: String, $time_window_start: String, $time_window_end: String, $pickup_time_window_start: String, $pickup_time_window_end: String, $type: String, $sorting_code: String, $a_scan_at: String, $packages: Int, $packagesDetail: [Json], $surcharges: [Json], $external_customer: Json, $fulfillment_center_code: String, $shipping_from: Int, $sender_name: String, $sender_company_name: String, $sender_email: String, $sender_telephone: String, $sender_country: String, $sender_province: String, $sender_city: String, $sender_address_1: String, $sender_address_2: String, $sender_postcode: String, $sender_address_type: String, $sender_code: String) { clientOrderCreate(customer_id: $customer_id, customer_code: $customer_code, postcode: $postcode, street_number: $street_number, street_name: $street_name, apt: $apt, buzz_code: $buzz_code, ref: $ref, order_code: $order_code, order_channel_code: $order_channel_code, carrier_name: $carrier_name, address_1: $address_1, address_2: $address_2, combine_address: $combine_address, city: $city, province: $province, country: $country, code: $code, name: $name, company_name: $company_name, email: $email, telephone: $telephone, note: $note, pickup_instruction: $pickup_instruction, delivery_instruction: $delivery_instruction, notification_language: $notification_language, skills: $skills, latitude: $latitude, longitude: $longitude, signature_option: $signature_option, insurance_option: $insurance_option, need_pick_up: $need_pick_up, allow_dropoff: $allow_dropoff, pin_verification_required: $pin_verification_required, self_pickup: $self_pickup, auto_deduplication: $auto_deduplication, service_time: $service_time, pickup_service_time: $pickup_service_time, pickup_date: $pickup_date, schedule_date: $schedule_date, time_window_start: $time_window_start, time_window_end: $time_window_end, pickup_time_window_start: $pickup_time_window_start, pickup_time_window_end: $pickup_time_window_end, type: $type, sorting_code: $sorting_code, a_scan_at: $a_scan_at, packages: $packages, packagesDetail: $packagesDetail, surcharges: $surcharges, external_customer: $external_customer, fulfillment_center_code: $fulfillment_center_code, shipping_from: $shipping_from, sender_name: $sender_name, sender_company_name: $sender_company_name, sender_email: $sender_email, sender_telephone: $sender_telephone, sender_country: $sender_country, sender_province: $sender_province, sender_city: $sender_city, sender_address_1: $sender_address_1, sender_address_2: $sender_address_2, sender_postcode: $sender_postcode, sender_address_type: $sender_address_type, sender_code: $sender_code) }', 'variables': {"customer_id":1,"customer_code":"example","postcode":"M5V 2T6","street_number":"example","street_name":"example","apt":"example","buzz_code":"example","ref":"example","order_code":"example","order_channel_code":"example","carrier_name":"example","address_1":"example","address_2":"example","combine_address":true,"city":"Toronto","province":"ON","country":"CA","code":"example","name":"example","company_name":"example","email":"user@example.com","telephone":"+14165551234","note":"example","pickup_instruction":"example","delivery_instruction":"example","notification_language":"example","skills":"example","latitude":1.5,"longitude":1.5,"signature_option":1,"insurance_option":1,"need_pick_up":1,"allow_dropoff":1,"pin_verification_required":1,"self_pickup":1,"auto_deduplication":1,"service_time":1,"pickup_service_time":1,"pickup_date":"2026-01-01","schedule_date":"2026-01-01","time_window_start":"example","time_window_end":"example","pickup_time_window_start":"example","pickup_time_window_end":"example","type":"example","sorting_code":"example","a_scan_at":"2026-01-01","packages":1,"packagesDetail":[{"key":"value"}],"surcharges":[{"key":"value"}],"external_customer":{"key":"value"},"fulfillment_center_code":"example","shipping_from":1,"sender_name":"example","sender_company_name":"example","sender_email":"user@example.com","sender_telephone":"+14165551234","sender_country":"CA","sender_province":"ON","sender_city":"Toronto","sender_address_1":"example","sender_address_2":"example","sender_postcode":"M5V 2T6","sender_address_type":"example","sender_code":"example"}, }, ) data = response.json() print(data)

package main import ( "bytes" "encoding/json" "fmt" "io" "net/http" ) func main() { payload, _ := json.Marshal(map[string]interface{}{ "query": `mutation ClientOrderCreate($customer_id: Int, $customer_code: String, $postcode: String, $street_number: String, $street_name: String, $apt: String, $buzz_code: String, $ref: String, $order_code: String, $order_channel_code: String, $carrier_name: String, $address_1: String, $address_2: String, $combine_address: Boolean, $city: String, $province: String, $country: String, $code: String, $name: String, $company_name: String, $email: String, $telephone: String, $note: String, $pickup_instruction: String, $delivery_instruction: String, $notification_language: String, $skills: String, $latitude: Float, $longitude: Float, $signature_option: Int, $insurance_option: Int, $need_pick_up: Int, $allow_dropoff: Int, $pin_verification_required: Int, $self_pickup: Int, $auto_deduplication: Int, $service_time: Int, $pickup_service_time: Int, $pickup_date: String, $schedule_date: String, $time_window_start: String, $time_window_end: String, $pickup_time_window_start: String, $pickup_time_window_end: String, $type: String, $sorting_code: String, $a_scan_at: String, $packages: Int, $packagesDetail: [Json], $surcharges: [Json], $external_customer: Json, $fulfillment_center_code: String, $shipping_from: Int, $sender_name: String, $sender_company_name: String, $sender_email: String, $sender_telephone: String, $sender_country: String, $sender_province: String, $sender_city: String, $sender_address_1: String, $sender_address_2: String, $sender_postcode: String, $sender_address_type: String, $sender_code: String) { clientOrderCreate(customer_id: $customer_id, customer_code: $customer_code, postcode: $postcode, street_number: $street_number, street_name: $street_name, apt: $apt, buzz_code: $buzz_code, ref: $ref, order_code: $order_code, order_channel_code: $order_channel_code, carrier_name: $carrier_name, address_1: $address_1, address_2: $address_2, combine_address: $combine_address, city: $city, province: $province, country: $country, code: $code, name: $name, company_name: $company_name, email: $email, telephone: $telephone, note: $note, pickup_instruction: $pickup_instruction, delivery_instruction: $delivery_instruction, notification_language: $notification_language, skills: $skills, latitude: $latitude, longitude: $longitude, signature_option: $signature_option, insurance_option: $insurance_option, need_pick_up: $need_pick_up, allow_dropoff: $allow_dropoff, pin_verification_required: $pin_verification_required, self_pickup: $self_pickup, auto_deduplication: $auto_deduplication, service_time: $service_time, pickup_service_time: $pickup_service_time, pickup_date: $pickup_date, schedule_date: $schedule_date, time_window_start: $time_window_start, time_window_end: $time_window_end, pickup_time_window_start: $pickup_time_window_start, pickup_time_window_end: $pickup_time_window_end, type: $type, sorting_code: $sorting_code, a_scan_at: $a_scan_at, packages: $packages, packagesDetail: $packagesDetail, surcharges: $surcharges, external_customer: $external_customer, fulfillment_center_code: $fulfillment_center_code, shipping_from: $shipping_from, sender_name: $sender_name, sender_company_name: $sender_company_name, sender_email: $sender_email, sender_telephone: $sender_telephone, sender_country: $sender_country, sender_province: $sender_province, sender_city: $sender_city, sender_address_1: $sender_address_1, sender_address_2: $sender_address_2, sender_postcode: $sender_postcode, sender_address_type: $sender_address_type, sender_code: $sender_code) }`, "variables": {"customer_id":1,"customer_code":"example","postcode":"M5V 2T6","street_number":"example","street_name":"example","apt":"example","buzz_code":"example","ref":"example","order_code":"example","order_channel_code":"example","carrier_name":"example","address_1":"example","address_2":"example","combine_address":true,"city":"Toronto","province":"ON","country":"CA","code":"example","name":"example","company_name":"example","email":"user@example.com","telephone":"+14165551234","note":"example","pickup_instruction":"example","delivery_instruction":"example","notification_language":"example","skills":"example","latitude":1.5,"longitude":1.5,"signature_option":1,"insurance_option":1,"need_pick_up":1,"allow_dropoff":1,"pin_verification_required":1,"self_pickup":1,"auto_deduplication":1,"service_time":1,"pickup_service_time":1,"pickup_date":"2026-01-01","schedule_date":"2026-01-01","time_window_start":"example","time_window_end":"example","pickup_time_window_start":"example","pickup_time_window_end":"example","type":"example","sorting_code":"example","a_scan_at":"2026-01-01","packages":1,"packagesDetail":[{"key":"value"}],"surcharges":[{"key":"value"}],"external_customer":{"key":"value"},"fulfillment_center_code":"example","shipping_from":1,"sender_name":"example","sender_company_name":"example","sender_email":"user@example.com","sender_telephone":"+14165551234","sender_country":"CA","sender_province":"ON","sender_city":"Toronto","sender_address_1":"example","sender_address_2":"example","sender_postcode":"M5V 2T6","sender_address_type":"example","sender_code":"example"}, }) req, _ := http.NewRequest("POST", "https://api.superlabel.ca/api/graphql", bytes.NewBuffer(payload)) req.Header.Set("Content-Type", "application/json") req.Header.Set("Accept", "application/json") req.Header.Set("Authorization", "Bearer YOUR_TOKEN") client := &http.Client{} resp, _ := client.Do(req) defer resp.Body.Close() body, _ := io.ReadAll(resp.Body) fmt.Println(string(body)) }

const response = await fetch('https://api.superlabel.ca/api/graphql', { method: 'POST', headers: { 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, body: JSON.stringify({ query: `mutation ClientOrderCreate($customer_id: Int, $customer_code: String, $postcode: String, $street_number: String, $street_name: String, $apt: String, $buzz_code: String, $ref: String, $order_code: String, $order_channel_code: String, $carrier_name: String, $address_1: String, $address_2: String, $combine_address: Boolean, $city: String, $province: String, $country: String, $code: String, $name: String, $company_name: String, $email: String, $telephone: String, $note: String, $pickup_instruction: String, $delivery_instruction: String, $notification_language: String, $skills: String, $latitude: Float, $longitude: Float, $signature_option: Int, $insurance_option: Int, $need_pick_up: Int, $allow_dropoff: Int, $pin_verification_required: Int, $self_pickup: Int, $auto_deduplication: Int, $service_time: Int, $pickup_service_time: Int, $pickup_date: String, $schedule_date: String, $time_window_start: String, $time_window_end: String, $pickup_time_window_start: String, $pickup_time_window_end: String, $type: String, $sorting_code: String, $a_scan_at: String, $packages: Int, $packagesDetail: [Json], $surcharges: [Json], $external_customer: Json, $fulfillment_center_code: String, $shipping_from: Int, $sender_name: String, $sender_company_name: String, $sender_email: String, $sender_telephone: String, $sender_country: String, $sender_province: String, $sender_city: String, $sender_address_1: String, $sender_address_2: String, $sender_postcode: String, $sender_address_type: String, $sender_code: String) { clientOrderCreate(customer_id: $customer_id, customer_code: $customer_code, postcode: $postcode, street_number: $street_number, street_name: $street_name, apt: $apt, buzz_code: $buzz_code, ref: $ref, order_code: $order_code, order_channel_code: $order_channel_code, carrier_name: $carrier_name, address_1: $address_1, address_2: $address_2, combine_address: $combine_address, city: $city, province: $province, country: $country, code: $code, name: $name, company_name: $company_name, email: $email, telephone: $telephone, note: $note, pickup_instruction: $pickup_instruction, delivery_instruction: $delivery_instruction, notification_language: $notification_language, skills: $skills, latitude: $latitude, longitude: $longitude, signature_option: $signature_option, insurance_option: $insurance_option, need_pick_up: $need_pick_up, allow_dropoff: $allow_dropoff, pin_verification_required: $pin_verification_required, self_pickup: $self_pickup, auto_deduplication: $auto_deduplication, service_time: $service_time, pickup_service_time: $pickup_service_time, pickup_date: $pickup_date, schedule_date: $schedule_date, time_window_start: $time_window_start, time_window_end: $time_window_end, pickup_time_window_start: $pickup_time_window_start, pickup_time_window_end: $pickup_time_window_end, type: $type, sorting_code: $sorting_code, a_scan_at: $a_scan_at, packages: $packages, packagesDetail: $packagesDetail, surcharges: $surcharges, external_customer: $external_customer, fulfillment_center_code: $fulfillment_center_code, shipping_from: $shipping_from, sender_name: $sender_name, sender_company_name: $sender_company_name, sender_email: $sender_email, sender_telephone: $sender_telephone, sender_country: $sender_country, sender_province: $sender_province, sender_city: $sender_city, sender_address_1: $sender_address_1, sender_address_2: $sender_address_2, sender_postcode: $sender_postcode, sender_address_type: $sender_address_type, sender_code: $sender_code) }`, variables: { "customer_id": 1, "customer_code": "example", "postcode": "M5V 2T6", "street_number": "example", "street_name": "example", "apt": "example", "buzz_code": "example", "ref": "example", "order_code": "example", "order_channel_code": "example", "carrier_name": "example", "address_1": "example", "address_2": "example", "combine_address": true, "city": "Toronto", "province": "ON", "country": "CA", "code": "example", "name": "example", "company_name": "example", "email": "user@example.com", "telephone": "+14165551234", "note": "example", "pickup_instruction": "example", "delivery_instruction": "example", "notification_language": "example", "skills": "example", "latitude": 1.5, "longitude": 1.5, "signature_option": 1, "insurance_option": 1, "need_pick_up": 1, "allow_dropoff": 1, "pin_verification_required": 1, "self_pickup": 1, "auto_deduplication": 1, "service_time": 1, "pickup_service_time": 1, "pickup_date": "2026-01-01", "schedule_date": "2026-01-01", "time_window_start": "example", "time_window_end": "example", "pickup_time_window_start": "example", "pickup_time_window_end": "example", "type": "example", "sorting_code": "example", "a_scan_at": "2026-01-01", "packages": 1, "packagesDetail": [ { "key": "value" } ], "surcharges": [ { "key": "value" } ], "external_customer": { "key": "value" }, "fulfillment_center_code": "example", "shipping_from": 1, "sender_name": "example", "sender_company_name": "example", "sender_email": "user@example.com", "sender_telephone": "+14165551234", "sender_country": "CA", "sender_province": "ON", "sender_city": "Toronto", "sender_address_1": "example", "sender_address_2": "example", "sender_postcode": "M5V 2T6", "sender_address_type": "example", "sender_code": "example" }, }), }); const data = await response.json(); console.log(data);

import java.net.http.*; import java.net.URI; HttpClient client = HttpClient.newHttpClient(); String body = "{\"query\":\"mutation ClientOrderCreate($customer_id: Int, $customer_code: String, $postcode: String, $street_number: String, $street_name: String, $apt: String, $buzz_code: String, $ref: String, $order_code: String, $order_channel_code: String, $carrier_name: String, $address_1: String, $address_2: String, $combine_address: Boolean, $city: String, $province: String, $country: String, $code: String, $name: String, $company_name: String, $email: String, $telephone: String, $note: String, $pickup_instruction: String, $delivery_instruction: String, $notification_language: String, $skills: String, $latitude: Float, $longitude: Float, $signature_option: Int, $insurance_option: Int, $need_pick_up: Int, $allow_dropoff: Int, $pin_verification_required: Int, $self_pickup: Int, $auto_deduplication: Int, $service_time: Int, $pickup_service_time: Int, $pickup_date: String, $schedule_date: String, $time_window_start: String, $time_window_end: String, $pickup_time_window_start: String, $pickup_time_window_end: String, $type: String, $sorting_code: String, $a_scan_at: String, $packages: Int, $packagesDetail: [Json], $surcharges: [Json], $external_customer: Json, $fulfillment_center_code: String, $shipping_from: Int, $sender_name: String, $sender_company_name: String, $sender_email: String, $sender_telephone: String, $sender_country: String, $sender_province: String, $sender_city: String, $sender_address_1: String, $sender_address_2: String, $sender_postcode: String, $sender_address_type: String, $sender_code: String) {\\n clientOrderCreate(customer_id: $customer_id, customer_code: $customer_code, postcode: $postcode, street_number: $street_number, street_name: $street_name, apt: $apt, buzz_code: $buzz_code, ref: $ref, order_code: $order_code, order_channel_code: $order_channel_code, carrier_name: $carrier_name, address_1: $address_1, address_2: $address_2, combine_address: $combine_address, city: $city, province: $province, country: $country, code: $code, name: $name, company_name: $company_name, email: $email, telephone: $telephone, note: $note, pickup_instruction: $pickup_instruction, delivery_instruction: $delivery_instruction, notification_language: $notification_language, skills: $skills, latitude: $latitude, longitude: $longitude, signature_option: $signature_option, insurance_option: $insurance_option, need_pick_up: $need_pick_up, allow_dropoff: $allow_dropoff, pin_verification_required: $pin_verification_required, self_pickup: $self_pickup, auto_deduplication: $auto_deduplication, service_time: $service_time, pickup_service_time: $pickup_service_time, pickup_date: $pickup_date, schedule_date: $schedule_date, time_window_start: $time_window_start, time_window_end: $time_window_end, pickup_time_window_start: $pickup_time_window_start, pickup_time_window_end: $pickup_time_window_end, type: $type, sorting_code: $sorting_code, a_scan_at: $a_scan_at, packages: $packages, packagesDetail: $packagesDetail, surcharges: $surcharges, external_customer: $external_customer, fulfillment_center_code: $fulfillment_center_code, shipping_from: $shipping_from, sender_name: $sender_name, sender_company_name: $sender_company_name, sender_email: $sender_email, sender_telephone: $sender_telephone, sender_country: $sender_country, sender_province: $sender_province, sender_city: $sender_city, sender_address_1: $sender_address_1, sender_address_2: $sender_address_2, sender_postcode: $sender_postcode, sender_address_type: $sender_address_type, sender_code: $sender_code)\\n}\",\"variables\":{\"customer_id\":1,\"customer_code\":\"example\",\"postcode\":\"M5V 2T6\",\"street_number\":\"example\",\"street_name\":\"example\",\"apt\":\"example\",\"buzz_code\":\"example\",\"ref\":\"example\",\"order_code\":\"example\",\"order_channel_code\":\"example\",\"carrier_name\":\"example\",\"address_1\":\"example\",\"address_2\":\"example\",\"combine_address\":true,\"city\":\"Toronto\",\"province\":\"ON\",\"country\":\"CA\",\"code\":\"example\",\"name\":\"example\",\"company_name\":\"example\",\"email\":\"user@example.com\",\"telephone\":\"+14165551234\",\"note\":\"example\",\"pickup_instruction\":\"example\",\"delivery_instruction\":\"example\",\"notification_language\":\"example\",\"skills\":\"example\",\"latitude\":1.5,\"longitude\":1.5,\"signature_option\":1,\"insurance_option\":1,\"need_pick_up\":1,\"allow_dropoff\":1,\"pin_verification_required\":1,\"self_pickup\":1,\"auto_deduplication\":1,\"service_time\":1,\"pickup_service_time\":1,\"pickup_date\":\"2026-01-01\",\"schedule_date\":\"2026-01-01\",\"time_window_start\":\"example\",\"time_window_end\":\"example\",\"pickup_time_window_start\":\"example\",\"pickup_time_window_end\":\"example\",\"type\":\"example\",\"sorting_code\":\"example\",\"a_scan_at\":\"2026-01-01\",\"packages\":1,\"packagesDetail\":[{\"key\":\"value\"}],\"surcharges\":[{\"key\":\"value\"}],\"external_customer\":{\"key\":\"value\"},\"fulfillment_center_code\":\"example\",\"shipping_from\":1,\"sender_name\":\"example\",\"sender_company_name\":\"example\",\"sender_email\":\"user@example.com\",\"sender_telephone\":\"+14165551234\",\"sender_country\":\"CA\",\"sender_province\":\"ON\",\"sender_city\":\"Toronto\",\"sender_address_1\":\"example\",\"sender_address_2\":\"example\",\"sender_postcode\":\"M5V 2T6\",\"sender_address_type\":\"example\",\"sender_code\":\"example\"}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.superlabel.ca/api/graphql")) .header("Content-Type", "application/json") .header("Accept", "application/json") .header("Authorization", "Bearer YOUR_TOKEN") .POST(HttpRequest.BodyPublishers.ofString(body)) .build(); HttpResponse<String> response = client.send( request, HttpResponse.BodyHandlers.ofString() ); System.out.println(response.body());

require 'net/http' require 'json' require 'uri' uri = URI.parse('https://api.superlabel.ca/api/graphql') http = Net::HTTP.new(uri.host, uri.port) http.use_ssl = uri.scheme == 'https' request = Net::HTTP::Post.new(uri) request.content_type = 'application/json' request['Accept'] = 'application/json' request['Authorization'] = 'Bearer YOUR_TOKEN' request.body = JSON.dump({ query: 'mutation ClientOrderCreate($customer_id: Int, $customer_code: String, $postcode: String, $street_number: String, $street_name: String, $apt: String, $buzz_code: String, $ref: String, $order_code: String, $order_channel_code: String, $carrier_name: String, $address_1: String, $address_2: String, $combine_address: Boolean, $city: String, $province: String, $country: String, $code: String, $name: String, $company_name: String, $email: String, $telephone: String, $note: String, $pickup_instruction: String, $delivery_instruction: String, $notification_language: String, $skills: String, $latitude: Float, $longitude: Float, $signature_option: Int, $insurance_option: Int, $need_pick_up: Int, $allow_dropoff: Int, $pin_verification_required: Int, $self_pickup: Int, $auto_deduplication: Int, $service_time: Int, $pickup_service_time: Int, $pickup_date: String, $schedule_date: String, $time_window_start: String, $time_window_end: String, $pickup_time_window_start: String, $pickup_time_window_end: String, $type: String, $sorting_code: String, $a_scan_at: String, $packages: Int, $packagesDetail: [Json], $surcharges: [Json], $external_customer: Json, $fulfillment_center_code: String, $shipping_from: Int, $sender_name: String, $sender_company_name: String, $sender_email: String, $sender_telephone: String, $sender_country: String, $sender_province: String, $sender_city: String, $sender_address_1: String, $sender_address_2: String, $sender_postcode: String, $sender_address_type: String, $sender_code: String) { clientOrderCreate(customer_id: $customer_id, customer_code: $customer_code, postcode: $postcode, street_number: $street_number, street_name: $street_name, apt: $apt, buzz_code: $buzz_code, ref: $ref, order_code: $order_code, order_channel_code: $order_channel_code, carrier_name: $carrier_name, address_1: $address_1, address_2: $address_2, combine_address: $combine_address, city: $city, province: $province, country: $country, code: $code, name: $name, company_name: $company_name, email: $email, telephone: $telephone, note: $note, pickup_instruction: $pickup_instruction, delivery_instruction: $delivery_instruction, notification_language: $notification_language, skills: $skills, latitude: $latitude, longitude: $longitude, signature_option: $signature_option, insurance_option: $insurance_option, need_pick_up: $need_pick_up, allow_dropoff: $allow_dropoff, pin_verification_required: $pin_verification_required, self_pickup: $self_pickup, auto_deduplication: $auto_deduplication, service_time: $service_time, pickup_service_time: $pickup_service_time, pickup_date: $pickup_date, schedule_date: $schedule_date, time_window_start: $time_window_start, time_window_end: $time_window_end, pickup_time_window_start: $pickup_time_window_start, pickup_time_window_end: $pickup_time_window_end, type: $type, sorting_code: $sorting_code, a_scan_at: $a_scan_at, packages: $packages, packagesDetail: $packagesDetail, surcharges: $surcharges, external_customer: $external_customer, fulfillment_center_code: $fulfillment_center_code, shipping_from: $shipping_from, sender_name: $sender_name, sender_company_name: $sender_company_name, sender_email: $sender_email, sender_telephone: $sender_telephone, sender_country: $sender_country, sender_province: $sender_province, sender_city: $sender_city, sender_address_1: $sender_address_1, sender_address_2: $sender_address_2, sender_postcode: $sender_postcode, sender_address_type: $sender_address_type, sender_code: $sender_code) }', variables: {"customer_id":1,"customer_code":"example","postcode":"M5V 2T6","street_number":"example","street_name":"example","apt":"example","buzz_code":"example","ref":"example","order_code":"example","order_channel_code":"example","carrier_name":"example","address_1":"example","address_2":"example","combine_address":true,"city":"Toronto","province":"ON","country":"CA","code":"example","name":"example","company_name":"example","email":"user@example.com","telephone":"+14165551234","note":"example","pickup_instruction":"example","delivery_instruction":"example","notification_language":"example","skills":"example","latitude":1.5,"longitude":1.5,"signature_option":1,"insurance_option":1,"need_pick_up":1,"allow_dropoff":1,"pin_verification_required":1,"self_pickup":1,"auto_deduplication":1,"service_time":1,"pickup_service_time":1,"pickup_date":"2026-01-01","schedule_date":"2026-01-01","time_window_start":"example","time_window_end":"example","pickup_time_window_start":"example","pickup_time_window_end":"example","type":"example","sorting_code":"example","a_scan_at":"2026-01-01","packages":1,"packagesDetail":[{"key":"value"}],"surcharges":[{"key":"value"}],"external_customer":{"key":"value"},"fulfillment_center_code":"example","shipping_from":1,"sender_name":"example","sender_company_name":"example","sender_email":"user@example.com","sender_telephone":"+14165551234","sender_country":"CA","sender_province":"ON","sender_city":"Toronto","sender_address_1":"example","sender_address_2":"example","sender_postcode":"M5V 2T6","sender_address_type":"example","sender_code":"example"} }) response = http.request(request) puts JSON.parse(response.body)

<?php require 'vendor/autoload.php'; $client = new GuzzleHttp\Client(); $response = $client->post('https://api.superlabel.ca/api/graphql', [ 'headers' => [ 'Content-Type' => 'application/json', 'Accept' => 'application/json', 'Authorization' => 'Bearer YOUR_TOKEN', ], 'json' => [ 'query' => 'mutation ClientOrdersBatchReceivePackage($order_batch: String) { clientOrdersBatchReceivePackage(order_batch: $order_batch) }', 'variables' => json_decode('{"order_batch":"example"}', true), ], ]); $data = json_decode($response->getBody(), true); print_r($data);

import requests response = requests.post( 'https://api.superlabel.ca/api/graphql', headers={ 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, json={ 'query': 'mutation ClientOrdersBatchReceivePackage($order_batch: String) { clientOrdersBatchReceivePackage(order_batch: $order_batch) }', 'variables': {"order_batch":"example"}, }, ) data = response.json() print(data)

package main import ( "bytes" "encoding/json" "fmt" "io" "net/http" ) func main() { payload, _ := json.Marshal(map[string]interface{}{ "query": `mutation ClientOrdersBatchReceivePackage($order_batch: String) { clientOrdersBatchReceivePackage(order_batch: $order_batch) }`, "variables": {"order_batch":"example"}, }) req, _ := http.NewRequest("POST", "https://api.superlabel.ca/api/graphql", bytes.NewBuffer(payload)) req.Header.Set("Content-Type", "application/json") req.Header.Set("Accept", "application/json") req.Header.Set("Authorization", "Bearer YOUR_TOKEN") client := &http.Client{} resp, _ := client.Do(req) defer resp.Body.Close() body, _ := io.ReadAll(resp.Body) fmt.Println(string(body)) }

const response = await fetch('https://api.superlabel.ca/api/graphql', { method: 'POST', headers: { 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, body: JSON.stringify({ query: `mutation ClientOrdersBatchReceivePackage($order_batch: String) { clientOrdersBatchReceivePackage(order_batch: $order_batch) }`, variables: { "order_batch": "example" }, }), }); const data = await response.json(); console.log(data);

import java.net.http.*; import java.net.URI; HttpClient client = HttpClient.newHttpClient(); String body = "{\"query\":\"mutation ClientOrdersBatchReceivePackage($order_batch: String) {\\n clientOrdersBatchReceivePackage(order_batch: $order_batch)\\n}\",\"variables\":{\"order_batch\":\"example\"}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.superlabel.ca/api/graphql")) .header("Content-Type", "application/json") .header("Accept", "application/json") .header("Authorization", "Bearer YOUR_TOKEN") .POST(HttpRequest.BodyPublishers.ofString(body)) .build(); HttpResponse<String> response = client.send( request, HttpResponse.BodyHandlers.ofString() ); System.out.println(response.body());

require 'net/http' require 'json' require 'uri' uri = URI.parse('https://api.superlabel.ca/api/graphql') http = Net::HTTP.new(uri.host, uri.port) http.use_ssl = uri.scheme == 'https' request = Net::HTTP::Post.new(uri) request.content_type = 'application/json' request['Accept'] = 'application/json' request['Authorization'] = 'Bearer YOUR_TOKEN' request.body = JSON.dump({ query: 'mutation ClientOrdersBatchReceivePackage($order_batch: String) { clientOrdersBatchReceivePackage(order_batch: $order_batch) }', variables: {"order_batch":"example"} }) response = http.request(request) puts JSON.parse(response.body)

<?php require 'vendor/autoload.php'; $client = new GuzzleHttp\Client(); $response = $client->post('https://api.superlabel.ca/api/graphql', [ 'headers' => [ 'Content-Type' => 'application/json', 'Accept' => 'application/json', 'Authorization' => 'Bearer YOUR_TOKEN', ], 'json' => [ 'query' => 'mutation ClientOrdersReceivePackage($search: String) { clientOrdersReceivePackage(search: $search) }', 'variables' => json_decode('{"search":"example"}', true), ], ]); $data = json_decode($response->getBody(), true); print_r($data);

import requests response = requests.post( 'https://api.superlabel.ca/api/graphql', headers={ 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, json={ 'query': 'mutation ClientOrdersReceivePackage($search: String) { clientOrdersReceivePackage(search: $search) }', 'variables': {"search":"example"}, }, ) data = response.json() print(data)

package main import ( "bytes" "encoding/json" "fmt" "io" "net/http" ) func main() { payload, _ := json.Marshal(map[string]interface{}{ "query": `mutation ClientOrdersReceivePackage($search: String) { clientOrdersReceivePackage(search: $search) }`, "variables": {"search":"example"}, }) req, _ := http.NewRequest("POST", "https://api.superlabel.ca/api/graphql", bytes.NewBuffer(payload)) req.Header.Set("Content-Type", "application/json") req.Header.Set("Accept", "application/json") req.Header.Set("Authorization", "Bearer YOUR_TOKEN") client := &http.Client{} resp, _ := client.Do(req) defer resp.Body.Close() body, _ := io.ReadAll(resp.Body) fmt.Println(string(body)) }

const response = await fetch('https://api.superlabel.ca/api/graphql', { method: 'POST', headers: { 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, body: JSON.stringify({ query: `mutation ClientOrdersReceivePackage($search: String) { clientOrdersReceivePackage(search: $search) }`, variables: { "search": "example" }, }), }); const data = await response.json(); console.log(data);

import java.net.http.*; import java.net.URI; HttpClient client = HttpClient.newHttpClient(); String body = "{\"query\":\"mutation ClientOrdersReceivePackage($search: String) {\\n clientOrdersReceivePackage(search: $search)\\n}\",\"variables\":{\"search\":\"example\"}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.superlabel.ca/api/graphql")) .header("Content-Type", "application/json") .header("Accept", "application/json") .header("Authorization", "Bearer YOUR_TOKEN") .POST(HttpRequest.BodyPublishers.ofString(body)) .build(); HttpResponse<String> response = client.send( request, HttpResponse.BodyHandlers.ofString() ); System.out.println(response.body());

require 'net/http' require 'json' require 'uri' uri = URI.parse('https://api.superlabel.ca/api/graphql') http = Net::HTTP.new(uri.host, uri.port) http.use_ssl = uri.scheme == 'https' request = Net::HTTP::Post.new(uri) request.content_type = 'application/json' request['Accept'] = 'application/json' request['Authorization'] = 'Bearer YOUR_TOKEN' request.body = JSON.dump({ query: 'mutation ClientOrdersReceivePackage($search: String) { clientOrdersReceivePackage(search: $search) }', variables: {"search":"example"} }) response = http.request(request) puts JSON.parse(response.body)

<?php require 'vendor/autoload.php'; $client = new GuzzleHttp\Client(); $response = $client->post('https://api.superlabel.ca/api/graphql', [ 'headers' => [ 'Content-Type' => 'application/json', 'Accept' => 'application/json', 'Authorization' => 'Bearer YOUR_TOKEN', ], 'json' => [ 'query' => 'mutation ClientRoutesAddOrder($route_id: Int, $driver_id: Int, $order_ids: [String]) { clientRoutesAddOrder(route_id: $route_id, driver_id: $driver_id, order_ids: $order_ids) }', 'variables' => json_decode('{"route_id":1,"driver_id":1,"order_ids":["example"]}', true), ], ]); $data = json_decode($response->getBody(), true); print_r($data);

import requests response = requests.post( 'https://api.superlabel.ca/api/graphql', headers={ 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, json={ 'query': 'mutation ClientRoutesAddOrder($route_id: Int, $driver_id: Int, $order_ids: [String]) { clientRoutesAddOrder(route_id: $route_id, driver_id: $driver_id, order_ids: $order_ids) }', 'variables': {"route_id":1,"driver_id":1,"order_ids":["example"]}, }, ) data = response.json() print(data)

package main import ( "bytes" "encoding/json" "fmt" "io" "net/http" ) func main() { payload, _ := json.Marshal(map[string]interface{}{ "query": `mutation ClientRoutesAddOrder($route_id: Int, $driver_id: Int, $order_ids: [String]) { clientRoutesAddOrder(route_id: $route_id, driver_id: $driver_id, order_ids: $order_ids) }`, "variables": {"route_id":1,"driver_id":1,"order_ids":["example"]}, }) req, _ := http.NewRequest("POST", "https://api.superlabel.ca/api/graphql", bytes.NewBuffer(payload)) req.Header.Set("Content-Type", "application/json") req.Header.Set("Accept", "application/json") req.Header.Set("Authorization", "Bearer YOUR_TOKEN") client := &http.Client{} resp, _ := client.Do(req) defer resp.Body.Close() body, _ := io.ReadAll(resp.Body) fmt.Println(string(body)) }

const response = await fetch('https://api.superlabel.ca/api/graphql', { method: 'POST', headers: { 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, body: JSON.stringify({ query: `mutation ClientRoutesAddOrder($route_id: Int, $driver_id: Int, $order_ids: [String]) { clientRoutesAddOrder(route_id: $route_id, driver_id: $driver_id, order_ids: $order_ids) }`, variables: { "route_id": 1, "driver_id": 1, "order_ids": [ "example" ] }, }), }); const data = await response.json(); console.log(data);

import java.net.http.*; import java.net.URI; HttpClient client = HttpClient.newHttpClient(); String body = "{\"query\":\"mutation ClientRoutesAddOrder($route_id: Int, $driver_id: Int, $order_ids: [String]) {\\n clientRoutesAddOrder(route_id: $route_id, driver_id: $driver_id, order_ids: $order_ids)\\n}\",\"variables\":{\"route_id\":1,\"driver_id\":1,\"order_ids\":[\"example\"]}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.superlabel.ca/api/graphql")) .header("Content-Type", "application/json") .header("Accept", "application/json") .header("Authorization", "Bearer YOUR_TOKEN") .POST(HttpRequest.BodyPublishers.ofString(body)) .build(); HttpResponse<String> response = client.send( request, HttpResponse.BodyHandlers.ofString() ); System.out.println(response.body());

require 'net/http' require 'json' require 'uri' uri = URI.parse('https://api.superlabel.ca/api/graphql') http = Net::HTTP.new(uri.host, uri.port) http.use_ssl = uri.scheme == 'https' request = Net::HTTP::Post.new(uri) request.content_type = 'application/json' request['Accept'] = 'application/json' request['Authorization'] = 'Bearer YOUR_TOKEN' request.body = JSON.dump({ query: 'mutation ClientRoutesAddOrder($route_id: Int, $driver_id: Int, $order_ids: [String]) { clientRoutesAddOrder(route_id: $route_id, driver_id: $driver_id, order_ids: $order_ids) }', variables: {"route_id":1,"driver_id":1,"order_ids":["example"]} }) response = http.request(request) puts JSON.parse(response.body)

<?php require 'vendor/autoload.php'; $client = new GuzzleHttp\Client(); $response = $client->post('https://api.superlabel.ca/api/graphql', [ 'headers' => [ 'Content-Type' => 'application/json', 'Accept' => 'application/json', 'Authorization' => 'Bearer YOUR_TOKEN', ], 'json' => [ 'query' => 'mutation ClientRoutesCancel($route_id: Int) { clientRoutesCancel(route_id: $route_id) }', 'variables' => json_decode('{"route_id":1}', true), ], ]); $data = json_decode($response->getBody(), true); print_r($data);

import requests response = requests.post( 'https://api.superlabel.ca/api/graphql', headers={ 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, json={ 'query': 'mutation ClientRoutesCancel($route_id: Int) { clientRoutesCancel(route_id: $route_id) }', 'variables': {"route_id":1}, }, ) data = response.json() print(data)

package main import ( "bytes" "encoding/json" "fmt" "io" "net/http" ) func main() { payload, _ := json.Marshal(map[string]interface{}{ "query": `mutation ClientRoutesCancel($route_id: Int) { clientRoutesCancel(route_id: $route_id) }`, "variables": {"route_id":1}, }) req, _ := http.NewRequest("POST", "https://api.superlabel.ca/api/graphql", bytes.NewBuffer(payload)) req.Header.Set("Content-Type", "application/json") req.Header.Set("Accept", "application/json") req.Header.Set("Authorization", "Bearer YOUR_TOKEN") client := &http.Client{} resp, _ := client.Do(req) defer resp.Body.Close() body, _ := io.ReadAll(resp.Body) fmt.Println(string(body)) }

const response = await fetch('https://api.superlabel.ca/api/graphql', { method: 'POST', headers: { 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, body: JSON.stringify({ query: `mutation ClientRoutesCancel($route_id: Int) { clientRoutesCancel(route_id: $route_id) }`, variables: { "route_id": 1 }, }), }); const data = await response.json(); console.log(data);

import java.net.http.*; import java.net.URI; HttpClient client = HttpClient.newHttpClient(); String body = "{\"query\":\"mutation ClientRoutesCancel($route_id: Int) {\\n clientRoutesCancel(route_id: $route_id)\\n}\",\"variables\":{\"route_id\":1}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.superlabel.ca/api/graphql")) .header("Content-Type", "application/json") .header("Accept", "application/json") .header("Authorization", "Bearer YOUR_TOKEN") .POST(HttpRequest.BodyPublishers.ofString(body)) .build(); HttpResponse<String> response = client.send( request, HttpResponse.BodyHandlers.ofString() ); System.out.println(response.body());

require 'net/http' require 'json' require 'uri' uri = URI.parse('https://api.superlabel.ca/api/graphql') http = Net::HTTP.new(uri.host, uri.port) http.use_ssl = uri.scheme == 'https' request = Net::HTTP::Post.new(uri) request.content_type = 'application/json' request['Accept'] = 'application/json' request['Authorization'] = 'Bearer YOUR_TOKEN' request.body = JSON.dump({ query: 'mutation ClientRoutesCancel($route_id: Int) { clientRoutesCancel(route_id: $route_id) }', variables: {"route_id":1} }) response = http.request(request) puts JSON.parse(response.body)

<?php require 'vendor/autoload.php'; $client = new GuzzleHttp\Client(); $response = $client->post('https://api.superlabel.ca/api/graphql', [ 'headers' => [ 'Content-Type' => 'application/json', 'Accept' => 'application/json', 'Authorization' => 'Bearer YOUR_TOKEN', ], 'json' => [ 'query' => 'mutation ClientRoutesMoveOrder($from_route_id: Int, $to_route_id: Int, $to_driver_id: Int, $order_ids: [String]) { clientRoutesMoveOrder(from_route_id: $from_route_id, to_route_id: $to_route_id, to_driver_id: $to_driver_id, order_ids: $order_ids) }', 'variables' => json_decode('{"from_route_id":1,"to_route_id":1,"to_driver_id":1,"order_ids":["example"]}', true), ], ]); $data = json_decode($response->getBody(), true); print_r($data);

import requests response = requests.post( 'https://api.superlabel.ca/api/graphql', headers={ 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, json={ 'query': 'mutation ClientRoutesMoveOrder($from_route_id: Int, $to_route_id: Int, $to_driver_id: Int, $order_ids: [String]) { clientRoutesMoveOrder(from_route_id: $from_route_id, to_route_id: $to_route_id, to_driver_id: $to_driver_id, order_ids: $order_ids) }', 'variables': {"from_route_id":1,"to_route_id":1,"to_driver_id":1,"order_ids":["example"]}, }, ) data = response.json() print(data)

package main import ( "bytes" "encoding/json" "fmt" "io" "net/http" ) func main() { payload, _ := json.Marshal(map[string]interface{}{ "query": `mutation ClientRoutesMoveOrder($from_route_id: Int, $to_route_id: Int, $to_driver_id: Int, $order_ids: [String]) { clientRoutesMoveOrder(from_route_id: $from_route_id, to_route_id: $to_route_id, to_driver_id: $to_driver_id, order_ids: $order_ids) }`, "variables": {"from_route_id":1,"to_route_id":1,"to_driver_id":1,"order_ids":["example"]}, }) req, _ := http.NewRequest("POST", "https://api.superlabel.ca/api/graphql", bytes.NewBuffer(payload)) req.Header.Set("Content-Type", "application/json") req.Header.Set("Accept", "application/json") req.Header.Set("Authorization", "Bearer YOUR_TOKEN") client := &http.Client{} resp, _ := client.Do(req) defer resp.Body.Close() body, _ := io.ReadAll(resp.Body) fmt.Println(string(body)) }

const response = await fetch('https://api.superlabel.ca/api/graphql', { method: 'POST', headers: { 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, body: JSON.stringify({ query: `mutation ClientRoutesMoveOrder($from_route_id: Int, $to_route_id: Int, $to_driver_id: Int, $order_ids: [String]) { clientRoutesMoveOrder(from_route_id: $from_route_id, to_route_id: $to_route_id, to_driver_id: $to_driver_id, order_ids: $order_ids) }`, variables: { "from_route_id": 1, "to_route_id": 1, "to_driver_id": 1, "order_ids": [ "example" ] }, }), }); const data = await response.json(); console.log(data);

import java.net.http.*; import java.net.URI; HttpClient client = HttpClient.newHttpClient(); String body = "{\"query\":\"mutation ClientRoutesMoveOrder($from_route_id: Int, $to_route_id: Int, $to_driver_id: Int, $order_ids: [String]) {\\n clientRoutesMoveOrder(from_route_id: $from_route_id, to_route_id: $to_route_id, to_driver_id: $to_driver_id, order_ids: $order_ids)\\n}\",\"variables\":{\"from_route_id\":1,\"to_route_id\":1,\"to_driver_id\":1,\"order_ids\":[\"example\"]}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.superlabel.ca/api/graphql")) .header("Content-Type", "application/json") .header("Accept", "application/json") .header("Authorization", "Bearer YOUR_TOKEN") .POST(HttpRequest.BodyPublishers.ofString(body)) .build(); HttpResponse<String> response = client.send( request, HttpResponse.BodyHandlers.ofString() ); System.out.println(response.body());

require 'net/http' require 'json' require 'uri' uri = URI.parse('https://api.superlabel.ca/api/graphql') http = Net::HTTP.new(uri.host, uri.port) http.use_ssl = uri.scheme == 'https' request = Net::HTTP::Post.new(uri) request.content_type = 'application/json' request['Accept'] = 'application/json' request['Authorization'] = 'Bearer YOUR_TOKEN' request.body = JSON.dump({ query: 'mutation ClientRoutesMoveOrder($from_route_id: Int, $to_route_id: Int, $to_driver_id: Int, $order_ids: [String]) { clientRoutesMoveOrder(from_route_id: $from_route_id, to_route_id: $to_route_id, to_driver_id: $to_driver_id, order_ids: $order_ids) }', variables: {"from_route_id":1,"to_route_id":1,"to_driver_id":1,"order_ids":["example"]} }) response = http.request(request) puts JSON.parse(response.body)

<?php require 'vendor/autoload.php'; $client = new GuzzleHttp\Client(); $response = $client->post('https://api.superlabel.ca/api/graphql', [ 'headers' => [ 'Content-Type' => 'application/json', 'Accept' => 'application/json', 'Authorization' => 'Bearer YOUR_TOKEN', ], 'json' => [ 'query' => 'mutation ClientRoutesOptimize($routeId: Int, $driverIds: [Int], $driverAddresses: Json, $async: Boolean) { clientRoutesOptimize(routeId: $routeId, driverIds: $driverIds, driverAddresses: $driverAddresses, async: $async) }', 'variables' => json_decode('{"routeId":1,"driverIds":[1],"driverAddresses":{"key":"value"},"async":true}', true), ], ]); $data = json_decode($response->getBody(), true); print_r($data);

import requests response = requests.post( 'https://api.superlabel.ca/api/graphql', headers={ 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, json={ 'query': 'mutation ClientRoutesOptimize($routeId: Int, $driverIds: [Int], $driverAddresses: Json, $async: Boolean) { clientRoutesOptimize(routeId: $routeId, driverIds: $driverIds, driverAddresses: $driverAddresses, async: $async) }', 'variables': {"routeId":1,"driverIds":[1],"driverAddresses":{"key":"value"},"async":true}, }, ) data = response.json() print(data)

package main import ( "bytes" "encoding/json" "fmt" "io" "net/http" ) func main() { payload, _ := json.Marshal(map[string]interface{}{ "query": `mutation ClientRoutesOptimize($routeId: Int, $driverIds: [Int], $driverAddresses: Json, $async: Boolean) { clientRoutesOptimize(routeId: $routeId, driverIds: $driverIds, driverAddresses: $driverAddresses, async: $async) }`, "variables": {"routeId":1,"driverIds":[1],"driverAddresses":{"key":"value"},"async":true}, }) req, _ := http.NewRequest("POST", "https://api.superlabel.ca/api/graphql", bytes.NewBuffer(payload)) req.Header.Set("Content-Type", "application/json") req.Header.Set("Accept", "application/json") req.Header.Set("Authorization", "Bearer YOUR_TOKEN") client := &http.Client{} resp, _ := client.Do(req) defer resp.Body.Close() body, _ := io.ReadAll(resp.Body) fmt.Println(string(body)) }

const response = await fetch('https://api.superlabel.ca/api/graphql', { method: 'POST', headers: { 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, body: JSON.stringify({ query: `mutation ClientRoutesOptimize($routeId: Int, $driverIds: [Int], $driverAddresses: Json, $async: Boolean) { clientRoutesOptimize(routeId: $routeId, driverIds: $driverIds, driverAddresses: $driverAddresses, async: $async) }`, variables: { "routeId": 1, "driverIds": [ 1 ], "driverAddresses": { "key": "value" }, "async": true }, }), }); const data = await response.json(); console.log(data);

import java.net.http.*; import java.net.URI; HttpClient client = HttpClient.newHttpClient(); String body = "{\"query\":\"mutation ClientRoutesOptimize($routeId: Int, $driverIds: [Int], $driverAddresses: Json, $async: Boolean) {\\n clientRoutesOptimize(routeId: $routeId, driverIds: $driverIds, driverAddresses: $driverAddresses, async: $async)\\n}\",\"variables\":{\"routeId\":1,\"driverIds\":[1],\"driverAddresses\":{\"key\":\"value\"},\"async\":true}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.superlabel.ca/api/graphql")) .header("Content-Type", "application/json") .header("Accept", "application/json") .header("Authorization", "Bearer YOUR_TOKEN") .POST(HttpRequest.BodyPublishers.ofString(body)) .build(); HttpResponse<String> response = client.send( request, HttpResponse.BodyHandlers.ofString() ); System.out.println(response.body());

require 'net/http' require 'json' require 'uri' uri = URI.parse('https://api.superlabel.ca/api/graphql') http = Net::HTTP.new(uri.host, uri.port) http.use_ssl = uri.scheme == 'https' request = Net::HTTP::Post.new(uri) request.content_type = 'application/json' request['Accept'] = 'application/json' request['Authorization'] = 'Bearer YOUR_TOKEN' request.body = JSON.dump({ query: 'mutation ClientRoutesOptimize($routeId: Int, $driverIds: [Int], $driverAddresses: Json, $async: Boolean) { clientRoutesOptimize(routeId: $routeId, driverIds: $driverIds, driverAddresses: $driverAddresses, async: $async) }', variables: {"routeId":1,"driverIds":[1],"driverAddresses":{"key":"value"},"async":true} }) response = http.request(request) puts JSON.parse(response.body)

<?php require 'vendor/autoload.php'; $client = new GuzzleHttp\Client(); $response = $client->post('https://api.superlabel.ca/api/graphql', [ 'headers' => [ 'Content-Type' => 'application/json', 'Accept' => 'application/json', 'Authorization' => 'Bearer YOUR_TOKEN', ], 'json' => [ 'query' => 'mutation ClientRoutesRemoveOrder($route_id: Int, $order_ids: [String], $cancel_order: Int) { clientRoutesRemoveOrder(route_id: $route_id, order_ids: $order_ids, cancel_order: $cancel_order) }', 'variables' => json_decode('{"route_id":1,"order_ids":["example"],"cancel_order":1}', true), ], ]); $data = json_decode($response->getBody(), true); print_r($data);

import requests response = requests.post( 'https://api.superlabel.ca/api/graphql', headers={ 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, json={ 'query': 'mutation ClientRoutesRemoveOrder($route_id: Int, $order_ids: [String], $cancel_order: Int) { clientRoutesRemoveOrder(route_id: $route_id, order_ids: $order_ids, cancel_order: $cancel_order) }', 'variables': {"route_id":1,"order_ids":["example"],"cancel_order":1}, }, ) data = response.json() print(data)

package main import ( "bytes" "encoding/json" "fmt" "io" "net/http" ) func main() { payload, _ := json.Marshal(map[string]interface{}{ "query": `mutation ClientRoutesRemoveOrder($route_id: Int, $order_ids: [String], $cancel_order: Int) { clientRoutesRemoveOrder(route_id: $route_id, order_ids: $order_ids, cancel_order: $cancel_order) }`, "variables": {"route_id":1,"order_ids":["example"],"cancel_order":1}, }) req, _ := http.NewRequest("POST", "https://api.superlabel.ca/api/graphql", bytes.NewBuffer(payload)) req.Header.Set("Content-Type", "application/json") req.Header.Set("Accept", "application/json") req.Header.Set("Authorization", "Bearer YOUR_TOKEN") client := &http.Client{} resp, _ := client.Do(req) defer resp.Body.Close() body, _ := io.ReadAll(resp.Body) fmt.Println(string(body)) }

const response = await fetch('https://api.superlabel.ca/api/graphql', { method: 'POST', headers: { 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, body: JSON.stringify({ query: `mutation ClientRoutesRemoveOrder($route_id: Int, $order_ids: [String], $cancel_order: Int) { clientRoutesRemoveOrder(route_id: $route_id, order_ids: $order_ids, cancel_order: $cancel_order) }`, variables: { "route_id": 1, "order_ids": [ "example" ], "cancel_order": 1 }, }), }); const data = await response.json(); console.log(data);

import java.net.http.*; import java.net.URI; HttpClient client = HttpClient.newHttpClient(); String body = "{\"query\":\"mutation ClientRoutesRemoveOrder($route_id: Int, $order_ids: [String], $cancel_order: Int) {\\n clientRoutesRemoveOrder(route_id: $route_id, order_ids: $order_ids, cancel_order: $cancel_order)\\n}\",\"variables\":{\"route_id\":1,\"order_ids\":[\"example\"],\"cancel_order\":1}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.superlabel.ca/api/graphql")) .header("Content-Type", "application/json") .header("Accept", "application/json") .header("Authorization", "Bearer YOUR_TOKEN") .POST(HttpRequest.BodyPublishers.ofString(body)) .build(); HttpResponse<String> response = client.send( request, HttpResponse.BodyHandlers.ofString() ); System.out.println(response.body());

require 'net/http' require 'json' require 'uri' uri = URI.parse('https://api.superlabel.ca/api/graphql') http = Net::HTTP.new(uri.host, uri.port) http.use_ssl = uri.scheme == 'https' request = Net::HTTP::Post.new(uri) request.content_type = 'application/json' request['Accept'] = 'application/json' request['Authorization'] = 'Bearer YOUR_TOKEN' request.body = JSON.dump({ query: 'mutation ClientRoutesRemoveOrder($route_id: Int, $order_ids: [String], $cancel_order: Int) { clientRoutesRemoveOrder(route_id: $route_id, order_ids: $order_ids, cancel_order: $cancel_order) }', variables: {"route_id":1,"order_ids":["example"],"cancel_order":1} }) response = http.request(request) puts JSON.parse(response.body)

<?php require 'vendor/autoload.php'; $client = new GuzzleHttp\Client(); $response = $client->post('https://api.superlabel.ca/api/graphql', [ 'headers' => [ 'Content-Type' => 'application/json', 'Accept' => 'application/json', 'Authorization' => 'Bearer YOUR_TOKEN', ], 'json' => [ 'query' => 'mutation ClientRoutesReplaceDriver($routeId: Int, $fromDriverId: Int, $toDriverId: Int) { clientRoutesReplaceDriver(routeId: $routeId, fromDriverId: $fromDriverId, toDriverId: $toDriverId) }', 'variables' => json_decode('{"routeId":1,"fromDriverId":1,"toDriverId":1}', true), ], ]); $data = json_decode($response->getBody(), true); print_r($data);

import requests response = requests.post( 'https://api.superlabel.ca/api/graphql', headers={ 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, json={ 'query': 'mutation ClientRoutesReplaceDriver($routeId: Int, $fromDriverId: Int, $toDriverId: Int) { clientRoutesReplaceDriver(routeId: $routeId, fromDriverId: $fromDriverId, toDriverId: $toDriverId) }', 'variables': {"routeId":1,"fromDriverId":1,"toDriverId":1}, }, ) data = response.json() print(data)

package main import ( "bytes" "encoding/json" "fmt" "io" "net/http" ) func main() { payload, _ := json.Marshal(map[string]interface{}{ "query": `mutation ClientRoutesReplaceDriver($routeId: Int, $fromDriverId: Int, $toDriverId: Int) { clientRoutesReplaceDriver(routeId: $routeId, fromDriverId: $fromDriverId, toDriverId: $toDriverId) }`, "variables": {"routeId":1,"fromDriverId":1,"toDriverId":1}, }) req, _ := http.NewRequest("POST", "https://api.superlabel.ca/api/graphql", bytes.NewBuffer(payload)) req.Header.Set("Content-Type", "application/json") req.Header.Set("Accept", "application/json") req.Header.Set("Authorization", "Bearer YOUR_TOKEN") client := &http.Client{} resp, _ := client.Do(req) defer resp.Body.Close() body, _ := io.ReadAll(resp.Body) fmt.Println(string(body)) }

const response = await fetch('https://api.superlabel.ca/api/graphql', { method: 'POST', headers: { 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, body: JSON.stringify({ query: `mutation ClientRoutesReplaceDriver($routeId: Int, $fromDriverId: Int, $toDriverId: Int) { clientRoutesReplaceDriver(routeId: $routeId, fromDriverId: $fromDriverId, toDriverId: $toDriverId) }`, variables: { "routeId": 1, "fromDriverId": 1, "toDriverId": 1 }, }), }); const data = await response.json(); console.log(data);

import java.net.http.*; import java.net.URI; HttpClient client = HttpClient.newHttpClient(); String body = "{\"query\":\"mutation ClientRoutesReplaceDriver($routeId: Int, $fromDriverId: Int, $toDriverId: Int) {\\n clientRoutesReplaceDriver(routeId: $routeId, fromDriverId: $fromDriverId, toDriverId: $toDriverId)\\n}\",\"variables\":{\"routeId\":1,\"fromDriverId\":1,\"toDriverId\":1}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.superlabel.ca/api/graphql")) .header("Content-Type", "application/json") .header("Accept", "application/json") .header("Authorization", "Bearer YOUR_TOKEN") .POST(HttpRequest.BodyPublishers.ofString(body)) .build(); HttpResponse<String> response = client.send( request, HttpResponse.BodyHandlers.ofString() ); System.out.println(response.body());

require 'net/http' require 'json' require 'uri' uri = URI.parse('https://api.superlabel.ca/api/graphql') http = Net::HTTP.new(uri.host, uri.port) http.use_ssl = uri.scheme == 'https' request = Net::HTTP::Post.new(uri) request.content_type = 'application/json' request['Accept'] = 'application/json' request['Authorization'] = 'Bearer YOUR_TOKEN' request.body = JSON.dump({ query: 'mutation ClientRoutesReplaceDriver($routeId: Int, $fromDriverId: Int, $toDriverId: Int) { clientRoutesReplaceDriver(routeId: $routeId, fromDriverId: $fromDriverId, toDriverId: $toDriverId) }', variables: {"routeId":1,"fromDriverId":1,"toDriverId":1} }) response = http.request(request) puts JSON.parse(response.body)

<?php require 'vendor/autoload.php'; $client = new GuzzleHttp\Client(); $response = $client->post('https://api.superlabel.ca/api/graphql', [ 'headers' => [ 'Content-Type' => 'application/json', 'Accept' => 'application/json', 'Authorization' => 'Bearer YOUR_TOKEN', ], 'json' => [ 'query' => 'mutation CustomerCancelShipout($id: Int!, $reason: String) { customerCancelShipout(id: $id, reason: $reason) { result message } }', 'variables' => json_decode('{"id":1,"reason":"example"}', true), ], ]); $data = json_decode($response->getBody(), true); print_r($data);

import requests response = requests.post( 'https://api.superlabel.ca/api/graphql', headers={ 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, json={ 'query': 'mutation CustomerCancelShipout($id: Int!, $reason: String) { customerCancelShipout(id: $id, reason: $reason) { result message } }', 'variables': {"id":1,"reason":"example"}, }, ) data = response.json() print(data)

package main import ( "bytes" "encoding/json" "fmt" "io" "net/http" ) func main() { payload, _ := json.Marshal(map[string]interface{}{ "query": `mutation CustomerCancelShipout($id: Int!, $reason: String) { customerCancelShipout(id: $id, reason: $reason) { result message } }`, "variables": {"id":1,"reason":"example"}, }) req, _ := http.NewRequest("POST", "https://api.superlabel.ca/api/graphql", bytes.NewBuffer(payload)) req.Header.Set("Content-Type", "application/json") req.Header.Set("Accept", "application/json") req.Header.Set("Authorization", "Bearer YOUR_TOKEN") client := &http.Client{} resp, _ := client.Do(req) defer resp.Body.Close() body, _ := io.ReadAll(resp.Body) fmt.Println(string(body)) }

const response = await fetch('https://api.superlabel.ca/api/graphql', { method: 'POST', headers: { 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, body: JSON.stringify({ query: `mutation CustomerCancelShipout($id: Int!, $reason: String) { customerCancelShipout(id: $id, reason: $reason) { result message } }`, variables: { "id": 1, "reason": "example" }, }), }); const data = await response.json(); console.log(data);

import java.net.http.*; import java.net.URI; HttpClient client = HttpClient.newHttpClient(); String body = "{\"query\":\"mutation CustomerCancelShipout($id: Int!, $reason: String) {\\n customerCancelShipout(id: $id, reason: $reason) {\\n result\\n message\\n}\\n}\",\"variables\":{\"id\":1,\"reason\":\"example\"}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.superlabel.ca/api/graphql")) .header("Content-Type", "application/json") .header("Accept", "application/json") .header("Authorization", "Bearer YOUR_TOKEN") .POST(HttpRequest.BodyPublishers.ofString(body)) .build(); HttpResponse<String> response = client.send( request, HttpResponse.BodyHandlers.ofString() ); System.out.println(response.body());

require 'net/http' require 'json' require 'uri' uri = URI.parse('https://api.superlabel.ca/api/graphql') http = Net::HTTP.new(uri.host, uri.port) http.use_ssl = uri.scheme == 'https' request = Net::HTTP::Post.new(uri) request.content_type = 'application/json' request['Accept'] = 'application/json' request['Authorization'] = 'Bearer YOUR_TOKEN' request.body = JSON.dump({ query: 'mutation CustomerCancelShipout($id: Int!, $reason: String) { customerCancelShipout(id: $id, reason: $reason) { result message } }', variables: {"id":1,"reason":"example"} }) response = http.request(request) puts JSON.parse(response.body)

<?php require 'vendor/autoload.php'; $client = new GuzzleHttp\Client(); $response = $client->post('https://api.superlabel.ca/api/graphql', [ 'headers' => [ 'Content-Type' => 'application/json', 'Accept' => 'application/json', 'Authorization' => 'Bearer YOUR_TOKEN', ], 'json' => [ 'query' => 'mutation CustomerCreateShipoutOrder($service_code: String!, $warehouse_id: Int!, $storage_package_ids: [Int], $delivery_name: String!, $delivery_telephone: String!, $delivery_email: String, $delivery_address_1: String!, $delivery_address_2: String, $delivery_city: String!, $delivery_province: String!, $delivery_country: String!, $delivery_postcode: String!, $package: String, $scheduled_date: String, $time_window: String, $note: String, $reference: String) { customerCreateShipoutOrder(service_code: $service_code, warehouse_id: $warehouse_id, storage_package_ids: $storage_package_ids, delivery_name: $delivery_name, delivery_telephone: $delivery_telephone, delivery_email: $delivery_email, delivery_address_1: $delivery_address_1, delivery_address_2: $delivery_address_2, delivery_city: $delivery_city, delivery_province: $delivery_province, delivery_country: $delivery_country, delivery_postcode: $delivery_postcode, package: $package, scheduled_date: $scheduled_date, time_window: $time_window, note: $note, reference: $reference) { result message errors data { id status is_storage_shipout total_price price_breakdown has_items_needing_quote storage_package_ids } } }', 'variables' => json_decode('{"service_code":"example","warehouse_id":1,"storage_package_ids":[1],"delivery_name":"example","delivery_telephone":"+14165551234","delivery_email":"user@example.com","delivery_address_1":"example","delivery_address_2":"example","delivery_city":"Toronto","delivery_province":"ON","delivery_country":"CA","delivery_postcode":"M5V 2T6","package":"example","scheduled_date":"2026-01-01","time_window":"example","note":"example","reference":"example"}', true), ], ]); $data = json_decode($response->getBody(), true); print_r($data);

import requests response = requests.post( 'https://api.superlabel.ca/api/graphql', headers={ 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, json={ 'query': 'mutation CustomerCreateShipoutOrder($service_code: String!, $warehouse_id: Int!, $storage_package_ids: [Int], $delivery_name: String!, $delivery_telephone: String!, $delivery_email: String, $delivery_address_1: String!, $delivery_address_2: String, $delivery_city: String!, $delivery_province: String!, $delivery_country: String!, $delivery_postcode: String!, $package: String, $scheduled_date: String, $time_window: String, $note: String, $reference: String) { customerCreateShipoutOrder(service_code: $service_code, warehouse_id: $warehouse_id, storage_package_ids: $storage_package_ids, delivery_name: $delivery_name, delivery_telephone: $delivery_telephone, delivery_email: $delivery_email, delivery_address_1: $delivery_address_1, delivery_address_2: $delivery_address_2, delivery_city: $delivery_city, delivery_province: $delivery_province, delivery_country: $delivery_country, delivery_postcode: $delivery_postcode, package: $package, scheduled_date: $scheduled_date, time_window: $time_window, note: $note, reference: $reference) { result message errors data { id status is_storage_shipout total_price price_breakdown has_items_needing_quote storage_package_ids } } }', 'variables': {"service_code":"example","warehouse_id":1,"storage_package_ids":[1],"delivery_name":"example","delivery_telephone":"+14165551234","delivery_email":"user@example.com","delivery_address_1":"example","delivery_address_2":"example","delivery_city":"Toronto","delivery_province":"ON","delivery_country":"CA","delivery_postcode":"M5V 2T6","package":"example","scheduled_date":"2026-01-01","time_window":"example","note":"example","reference":"example"}, }, ) data = response.json() print(data)

package main import ( "bytes" "encoding/json" "fmt" "io" "net/http" ) func main() { payload, _ := json.Marshal(map[string]interface{}{ "query": `mutation CustomerCreateShipoutOrder($service_code: String!, $warehouse_id: Int!, $storage_package_ids: [Int], $delivery_name: String!, $delivery_telephone: String!, $delivery_email: String, $delivery_address_1: String!, $delivery_address_2: String, $delivery_city: String!, $delivery_province: String!, $delivery_country: String!, $delivery_postcode: String!, $package: String, $scheduled_date: String, $time_window: String, $note: String, $reference: String) { customerCreateShipoutOrder(service_code: $service_code, warehouse_id: $warehouse_id, storage_package_ids: $storage_package_ids, delivery_name: $delivery_name, delivery_telephone: $delivery_telephone, delivery_email: $delivery_email, delivery_address_1: $delivery_address_1, delivery_address_2: $delivery_address_2, delivery_city: $delivery_city, delivery_province: $delivery_province, delivery_country: $delivery_country, delivery_postcode: $delivery_postcode, package: $package, scheduled_date: $scheduled_date, time_window: $time_window, note: $note, reference: $reference) { result message errors data { id status is_storage_shipout total_price price_breakdown has_items_needing_quote storage_package_ids } } }`, "variables": {"service_code":"example","warehouse_id":1,"storage_package_ids":[1],"delivery_name":"example","delivery_telephone":"+14165551234","delivery_email":"user@example.com","delivery_address_1":"example","delivery_address_2":"example","delivery_city":"Toronto","delivery_province":"ON","delivery_country":"CA","delivery_postcode":"M5V 2T6","package":"example","scheduled_date":"2026-01-01","time_window":"example","note":"example","reference":"example"}, }) req, _ := http.NewRequest("POST", "https://api.superlabel.ca/api/graphql", bytes.NewBuffer(payload)) req.Header.Set("Content-Type", "application/json") req.Header.Set("Accept", "application/json") req.Header.Set("Authorization", "Bearer YOUR_TOKEN") client := &http.Client{} resp, _ := client.Do(req) defer resp.Body.Close() body, _ := io.ReadAll(resp.Body) fmt.Println(string(body)) }

const response = await fetch('https://api.superlabel.ca/api/graphql', { method: 'POST', headers: { 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, body: JSON.stringify({ query: `mutation CustomerCreateShipoutOrder($service_code: String!, $warehouse_id: Int!, $storage_package_ids: [Int], $delivery_name: String!, $delivery_telephone: String!, $delivery_email: String, $delivery_address_1: String!, $delivery_address_2: String, $delivery_city: String!, $delivery_province: String!, $delivery_country: String!, $delivery_postcode: String!, $package: String, $scheduled_date: String, $time_window: String, $note: String, $reference: String) { customerCreateShipoutOrder(service_code: $service_code, warehouse_id: $warehouse_id, storage_package_ids: $storage_package_ids, delivery_name: $delivery_name, delivery_telephone: $delivery_telephone, delivery_email: $delivery_email, delivery_address_1: $delivery_address_1, delivery_address_2: $delivery_address_2, delivery_city: $delivery_city, delivery_province: $delivery_province, delivery_country: $delivery_country, delivery_postcode: $delivery_postcode, package: $package, scheduled_date: $scheduled_date, time_window: $time_window, note: $note, reference: $reference) { result message errors data { id status is_storage_shipout total_price price_breakdown has_items_needing_quote storage_package_ids } } }`, variables: { "service_code": "example", "warehouse_id": 1, "storage_package_ids": [ 1 ], "delivery_name": "example", "delivery_telephone": "+14165551234", "delivery_email": "user@example.com", "delivery_address_1": "example", "delivery_address_2": "example", "delivery_city": "Toronto", "delivery_province": "ON", "delivery_country": "CA", "delivery_postcode": "M5V 2T6", "package": "example", "scheduled_date": "2026-01-01", "time_window": "example", "note": "example", "reference": "example" }, }), }); const data = await response.json(); console.log(data);

import java.net.http.*; import java.net.URI; HttpClient client = HttpClient.newHttpClient(); String body = "{\"query\":\"mutation CustomerCreateShipoutOrder($service_code: String!, $warehouse_id: Int!, $storage_package_ids: [Int], $delivery_name: String!, $delivery_telephone: String!, $delivery_email: String, $delivery_address_1: String!, $delivery_address_2: String, $delivery_city: String!, $delivery_province: String!, $delivery_country: String!, $delivery_postcode: String!, $package: String, $scheduled_date: String, $time_window: String, $note: String, $reference: String) {\\n customerCreateShipoutOrder(service_code: $service_code, warehouse_id: $warehouse_id, storage_package_ids: $storage_package_ids, delivery_name: $delivery_name, delivery_telephone: $delivery_telephone, delivery_email: $delivery_email, delivery_address_1: $delivery_address_1, delivery_address_2: $delivery_address_2, delivery_city: $delivery_city, delivery_province: $delivery_province, delivery_country: $delivery_country, delivery_postcode: $delivery_postcode, package: $package, scheduled_date: $scheduled_date, time_window: $time_window, note: $note, reference: $reference) {\\n result\\n message\\n errors\\n data {\\n id\\n status\\n is_storage_shipout\\n total_price\\n price_breakdown\\n has_items_needing_quote\\n storage_package_ids\\n }\\n}\\n}\",\"variables\":{\"service_code\":\"example\",\"warehouse_id\":1,\"storage_package_ids\":[1],\"delivery_name\":\"example\",\"delivery_telephone\":\"+14165551234\",\"delivery_email\":\"user@example.com\",\"delivery_address_1\":\"example\",\"delivery_address_2\":\"example\",\"delivery_city\":\"Toronto\",\"delivery_province\":\"ON\",\"delivery_country\":\"CA\",\"delivery_postcode\":\"M5V 2T6\",\"package\":\"example\",\"scheduled_date\":\"2026-01-01\",\"time_window\":\"example\",\"note\":\"example\",\"reference\":\"example\"}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.superlabel.ca/api/graphql")) .header("Content-Type", "application/json") .header("Accept", "application/json") .header("Authorization", "Bearer YOUR_TOKEN") .POST(HttpRequest.BodyPublishers.ofString(body)) .build(); HttpResponse<String> response = client.send( request, HttpResponse.BodyHandlers.ofString() ); System.out.println(response.body());

require 'net/http' require 'json' require 'uri' uri = URI.parse('https://api.superlabel.ca/api/graphql') http = Net::HTTP.new(uri.host, uri.port) http.use_ssl = uri.scheme == 'https' request = Net::HTTP::Post.new(uri) request.content_type = 'application/json' request['Accept'] = 'application/json' request['Authorization'] = 'Bearer YOUR_TOKEN' request.body = JSON.dump({ query: 'mutation CustomerCreateShipoutOrder($service_code: String!, $warehouse_id: Int!, $storage_package_ids: [Int], $delivery_name: String!, $delivery_telephone: String!, $delivery_email: String, $delivery_address_1: String!, $delivery_address_2: String, $delivery_city: String!, $delivery_province: String!, $delivery_country: String!, $delivery_postcode: String!, $package: String, $scheduled_date: String, $time_window: String, $note: String, $reference: String) { customerCreateShipoutOrder(service_code: $service_code, warehouse_id: $warehouse_id, storage_package_ids: $storage_package_ids, delivery_name: $delivery_name, delivery_telephone: $delivery_telephone, delivery_email: $delivery_email, delivery_address_1: $delivery_address_1, delivery_address_2: $delivery_address_2, delivery_city: $delivery_city, delivery_province: $delivery_province, delivery_country: $delivery_country, delivery_postcode: $delivery_postcode, package: $package, scheduled_date: $scheduled_date, time_window: $time_window, note: $note, reference: $reference) { result message errors data { id status is_storage_shipout total_price price_breakdown has_items_needing_quote storage_package_ids } } }', variables: {"service_code":"example","warehouse_id":1,"storage_package_ids":[1],"delivery_name":"example","delivery_telephone":"+14165551234","delivery_email":"user@example.com","delivery_address_1":"example","delivery_address_2":"example","delivery_city":"Toronto","delivery_province":"ON","delivery_country":"CA","delivery_postcode":"M5V 2T6","package":"example","scheduled_date":"2026-01-01","time_window":"example","note":"example","reference":"example"} }) response = http.request(request) puts JSON.parse(response.body)

<?php require 'vendor/autoload.php'; $client = new GuzzleHttp\Client(); $response = $client->post('https://api.superlabel.ca/api/graphql', [ 'headers' => [ 'Content-Type' => 'application/json', 'Accept' => 'application/json', 'Authorization' => 'Bearer YOUR_TOKEN', ], 'json' => [ 'query' => 'mutation CustomerPayShipout($id: Int!, $amount: Float) { customerPayShipout(id: $id, amount: $amount) { result message data { transaction_id amount order_status paid_amount remaining_balance } } }', 'variables' => json_decode('{"id":1,"amount":1.5}', true), ], ]); $data = json_decode($response->getBody(), true); print_r($data);

import requests response = requests.post( 'https://api.superlabel.ca/api/graphql', headers={ 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, json={ 'query': 'mutation CustomerPayShipout($id: Int!, $amount: Float) { customerPayShipout(id: $id, amount: $amount) { result message data { transaction_id amount order_status paid_amount remaining_balance } } }', 'variables': {"id":1,"amount":1.5}, }, ) data = response.json() print(data)

package main import ( "bytes" "encoding/json" "fmt" "io" "net/http" ) func main() { payload, _ := json.Marshal(map[string]interface{}{ "query": `mutation CustomerPayShipout($id: Int!, $amount: Float) { customerPayShipout(id: $id, amount: $amount) { result message data { transaction_id amount order_status paid_amount remaining_balance } } }`, "variables": {"id":1,"amount":1.5}, }) req, _ := http.NewRequest("POST", "https://api.superlabel.ca/api/graphql", bytes.NewBuffer(payload)) req.Header.Set("Content-Type", "application/json") req.Header.Set("Accept", "application/json") req.Header.Set("Authorization", "Bearer YOUR_TOKEN") client := &http.Client{} resp, _ := client.Do(req) defer resp.Body.Close() body, _ := io.ReadAll(resp.Body) fmt.Println(string(body)) }

const response = await fetch('https://api.superlabel.ca/api/graphql', { method: 'POST', headers: { 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, body: JSON.stringify({ query: `mutation CustomerPayShipout($id: Int!, $amount: Float) { customerPayShipout(id: $id, amount: $amount) { result message data { transaction_id amount order_status paid_amount remaining_balance } } }`, variables: { "id": 1, "amount": 1.5 }, }), }); const data = await response.json(); console.log(data);

import java.net.http.*; import java.net.URI; HttpClient client = HttpClient.newHttpClient(); String body = "{\"query\":\"mutation CustomerPayShipout($id: Int!, $amount: Float) {\\n customerPayShipout(id: $id, amount: $amount) {\\n result\\n message\\n data {\\n transaction_id\\n amount\\n order_status\\n paid_amount\\n remaining_balance\\n }\\n}\\n}\",\"variables\":{\"id\":1,\"amount\":1.5}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.superlabel.ca/api/graphql")) .header("Content-Type", "application/json") .header("Accept", "application/json") .header("Authorization", "Bearer YOUR_TOKEN") .POST(HttpRequest.BodyPublishers.ofString(body)) .build(); HttpResponse<String> response = client.send( request, HttpResponse.BodyHandlers.ofString() ); System.out.println(response.body());

require 'net/http' require 'json' require 'uri' uri = URI.parse('https://api.superlabel.ca/api/graphql') http = Net::HTTP.new(uri.host, uri.port) http.use_ssl = uri.scheme == 'https' request = Net::HTTP::Post.new(uri) request.content_type = 'application/json' request['Accept'] = 'application/json' request['Authorization'] = 'Bearer YOUR_TOKEN' request.body = JSON.dump({ query: 'mutation CustomerPayShipout($id: Int!, $amount: Float) { customerPayShipout(id: $id, amount: $amount) { result message data { transaction_id amount order_status paid_amount remaining_balance } } }', variables: {"id":1,"amount":1.5} }) response = http.request(request) puts JSON.parse(response.body)

<?php require 'vendor/autoload.php'; $client = new GuzzleHttp\Client(); $response = $client->post('https://api.superlabel.ca/api/graphql', [ 'headers' => [ 'Content-Type' => 'application/json', 'Accept' => 'application/json', 'Authorization' => 'Bearer YOUR_TOKEN', ], 'json' => [ 'query' => 'mutation CustomerSelectShipoutRate($id: Int!, $rate_id: String!) { customerSelectShipoutRate(id: $id, rate_id: $rate_id) { result message data { id total_price remaining_balance can_be_paid rate_id } } }', 'variables' => json_decode('{"id":1,"rate_id":"example"}', true), ], ]); $data = json_decode($response->getBody(), true); print_r($data);

import requests response = requests.post( 'https://api.superlabel.ca/api/graphql', headers={ 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, json={ 'query': 'mutation CustomerSelectShipoutRate($id: Int!, $rate_id: String!) { customerSelectShipoutRate(id: $id, rate_id: $rate_id) { result message data { id total_price remaining_balance can_be_paid rate_id } } }', 'variables': {"id":1,"rate_id":"example"}, }, ) data = response.json() print(data)

package main import ( "bytes" "encoding/json" "fmt" "io" "net/http" ) func main() { payload, _ := json.Marshal(map[string]interface{}{ "query": `mutation CustomerSelectShipoutRate($id: Int!, $rate_id: String!) { customerSelectShipoutRate(id: $id, rate_id: $rate_id) { result message data { id total_price remaining_balance can_be_paid rate_id } } }`, "variables": {"id":1,"rate_id":"example"}, }) req, _ := http.NewRequest("POST", "https://api.superlabel.ca/api/graphql", bytes.NewBuffer(payload)) req.Header.Set("Content-Type", "application/json") req.Header.Set("Accept", "application/json") req.Header.Set("Authorization", "Bearer YOUR_TOKEN") client := &http.Client{} resp, _ := client.Do(req) defer resp.Body.Close() body, _ := io.ReadAll(resp.Body) fmt.Println(string(body)) }

const response = await fetch('https://api.superlabel.ca/api/graphql', { method: 'POST', headers: { 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, body: JSON.stringify({ query: `mutation CustomerSelectShipoutRate($id: Int!, $rate_id: String!) { customerSelectShipoutRate(id: $id, rate_id: $rate_id) { result message data { id total_price remaining_balance can_be_paid rate_id } } }`, variables: { "id": 1, "rate_id": "example" }, }), }); const data = await response.json(); console.log(data);

import java.net.http.*; import java.net.URI; HttpClient client = HttpClient.newHttpClient(); String body = "{\"query\":\"mutation CustomerSelectShipoutRate($id: Int!, $rate_id: String!) {\\n customerSelectShipoutRate(id: $id, rate_id: $rate_id) {\\n result\\n message\\n data {\\n id\\n total_price\\n remaining_balance\\n can_be_paid\\n rate_id\\n }\\n}\\n}\",\"variables\":{\"id\":1,\"rate_id\":\"example\"}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.superlabel.ca/api/graphql")) .header("Content-Type", "application/json") .header("Accept", "application/json") .header("Authorization", "Bearer YOUR_TOKEN") .POST(HttpRequest.BodyPublishers.ofString(body)) .build(); HttpResponse<String> response = client.send( request, HttpResponse.BodyHandlers.ofString() ); System.out.println(response.body());

require 'net/http' require 'json' require 'uri' uri = URI.parse('https://api.superlabel.ca/api/graphql') http = Net::HTTP.new(uri.host, uri.port) http.use_ssl = uri.scheme == 'https' request = Net::HTTP::Post.new(uri) request.content_type = 'application/json' request['Accept'] = 'application/json' request['Authorization'] = 'Bearer YOUR_TOKEN' request.body = JSON.dump({ query: 'mutation CustomerSelectShipoutRate($id: Int!, $rate_id: String!) { customerSelectShipoutRate(id: $id, rate_id: $rate_id) { result message data { id total_price remaining_balance can_be_paid rate_id } } }', variables: {"id":1,"rate_id":"example"} }) response = http.request(request) puts JSON.parse(response.body)