Mili Express GraphQL API

<?php require 'vendor/autoload.php'; $client = new GuzzleHttp\Client(); $response = $client->post('https://api.miliexpress.com/api/graphql', [ 'headers' => [ 'Content-Type' => 'application/json', 'Accept' => 'application/json', ], 'json' => [ 'query' => 'mutation UserLogin($email: String, $password: String) { userLogin(email: $email, password: $password) }', 'variables' => json_decode('{"email":"example","password":"example"}', true), ], ]); $data = json_decode($response->getBody(), true); print_r($data);

import requests response = requests.post( 'https://api.miliexpress.com/api/graphql', headers={ 'Content-Type': 'application/json', 'Accept': 'application/json', }, json={ 'query': 'mutation UserLogin($email: String, $password: String) { userLogin(email: $email, password: $password) }', 'variables': {"email":"example","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 UserLogin($email: String, $password: String) { userLogin(email: $email, password: $password) }`, "variables": {"email":"example","password":"example"}, }) req, _ := http.NewRequest("POST", "https://api.miliexpress.com/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.miliexpress.com/api/graphql', { method: 'POST', headers: { 'Content-Type': 'application/json', 'Accept': 'application/json', }, body: JSON.stringify({ query: `mutation UserLogin($email: String, $password: String) { userLogin(email: $email, password: $password) }`, variables: { "email": "example", "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 UserLogin($email: String, $password: String) {\\n userLogin(email: $email, password: $password)\\n}\",\"variables\":{\"email\":\"example\",\"password\":\"example\"}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.miliexpress.com/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.miliexpress.com/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) { userLogin(email: $email, password: $password) }', variables: {"email":"example","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.miliexpress.com/api/graphql', [ 'headers' => [ 'Content-Type' => 'application/json', 'Accept' => 'application/json', 'Authorization' => 'Bearer YOUR_TOKEN', ], 'json' => [ 'query' => 'mutation UserRefreshToken { userRefreshToken }', 'variables' => [], ], ]); $data = json_decode($response->getBody(), true); print_r($data);

import requests response = requests.post( 'https://api.miliexpress.com/api/graphql', headers={ 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, json={ 'query': 'mutation UserRefreshToken { userRefreshToken }', '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 }`, "variables": map[string]interface{}{}, }) req, _ := http.NewRequest("POST", "https://api.miliexpress.com/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.miliexpress.com/api/graphql', { method: 'POST', headers: { 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, body: JSON.stringify({ query: `mutation UserRefreshToken { userRefreshToken }`, 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}\",\"variables\":{}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.miliexpress.com/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.miliexpress.com/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 }', variables: {} }) response = http.request(request) puts JSON.parse(response.body)

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

import requests response = requests.post( 'https://api.miliexpress.com/api/graphql', headers={ 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, json={ 'query': 'mutation DriverCreateRoute($name: String) { driverCreateRoute(name: $name) }', 'variables': {"name":"route_001"}, }, ) 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) { driverCreateRoute(name: $name) }`, "variables": {"name":"route_001"}, }) req, _ := http.NewRequest("POST", "https://api.miliexpress.com/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.miliexpress.com/api/graphql', { method: 'POST', headers: { 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, body: JSON.stringify({ query: `mutation DriverCreateRoute($name: String) { driverCreateRoute(name: $name) }`, variables: { "name": "route_001" }, }), }); 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) {\\n driverCreateRoute(name: $name)\\n}\",\"variables\":{\"name\":\"route_001\"}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.miliexpress.com/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.miliexpress.com/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) { driverCreateRoute(name: $name) }', variables: {"name":"route_001"} }) response = http.request(request) puts JSON.parse(response.body)

<?php require 'vendor/autoload.php'; $client = new GuzzleHttp\Client(); $response = $client->post('https://api.miliexpress.com/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":0}', true), ], ]); $data = json_decode($response->getBody(), true); print_r($data);

import requests response = requests.post( 'https://api.miliexpress.com/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":0}, }, ) 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":0}, }) req, _ := http.NewRequest("POST", "https://api.miliexpress.com/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.miliexpress.com/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": 0 }, }), }); 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\":0}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.miliexpress.com/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.miliexpress.com/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":0} }) response = http.request(request) puts JSON.parse(response.body)

<?php require 'vendor/autoload.php'; $client = new GuzzleHttp\Client(); $response = $client->post('https://api.miliexpress.com/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":456,"order_ids":[101,102,103]}', true), ], ]); $data = json_decode($response->getBody(), true); print_r($data);

import requests response = requests.post( 'https://api.miliexpress.com/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":456,"order_ids":[101,102,103]}, }, ) 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":456,"order_ids":[101,102,103]}, }) req, _ := http.NewRequest("POST", "https://api.miliexpress.com/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.miliexpress.com/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": 456, "order_ids": [ 101, 102, 103 ] }, }), }); 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\":456,\"order_ids\":[101,102,103]}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.miliexpress.com/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.miliexpress.com/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":456,"order_ids":[101,102,103]} }) response = http.request(request) puts JSON.parse(response.body)

<?php require 'vendor/autoload.php'; $client = new GuzzleHttp\Client(); $response = $client->post('https://api.miliexpress.com/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.miliexpress.com/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.miliexpress.com/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.miliexpress.com/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.miliexpress.com/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.miliexpress.com/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.miliexpress.com/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":1234,"order_ids":[5678]}', true), ], ]); $data = json_decode($response->getBody(), true); print_r($data);

import requests response = requests.post( 'https://api.miliexpress.com/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":1234,"order_ids":[5678]}, }, ) 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":1234,"order_ids":[5678]}, }) req, _ := http.NewRequest("POST", "https://api.miliexpress.com/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.miliexpress.com/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": 1234, "order_ids": [ 5678 ] }, }), }); 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\":1234,\"order_ids\":[5678]}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.miliexpress.com/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.miliexpress.com/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":1234,"order_ids":[5678]} }) response = http.request(request) puts JSON.parse(response.body)

<?php require 'vendor/autoload.php'; $client = new GuzzleHttp\Client(); $response = $client->post('https://api.miliexpress.com/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":12345,"packageIds":[1,2,3],"status":"NR","return_reason_id":1,"gps_tracking_id":1,"routeId":123}', true), ], ]); $data = json_decode($response->getBody(), true); print_r($data);

import requests response = requests.post( 'https://api.miliexpress.com/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":12345,"packageIds":[1,2,3],"status":"NR","return_reason_id":1,"gps_tracking_id":1,"routeId":123}, }, ) 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":12345,"packageIds":[1,2,3],"status":"NR","return_reason_id":1,"gps_tracking_id":1,"routeId":123}, }) req, _ := http.NewRequest("POST", "https://api.miliexpress.com/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.miliexpress.com/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": 12345, "packageIds": [ 1, 2, 3 ], "status": "NR", "return_reason_id": 1, "gps_tracking_id": 1, "routeId": 123 }, }), }); 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\":12345,\"packageIds\":[1,2,3],\"status\":\"NR\",\"return_reason_id\":1,\"gps_tracking_id\":1,\"routeId\":123}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.miliexpress.com/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.miliexpress.com/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":12345,"packageIds":[1,2,3],"status":"NR","return_reason_id":1,"gps_tracking_id":1,"routeId":123} }) response = http.request(request) puts JSON.parse(response.body)

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

import requests response = requests.post( 'https://api.miliexpress.com/api/graphql', headers={ 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, json={ 'query': 'mutation DriverAddGpsTackingRecord { driverAddGpsTackingRecord }', '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 DriverAddGpsTackingRecord { driverAddGpsTackingRecord }`, "variables": map[string]interface{}{}, }) req, _ := http.NewRequest("POST", "https://api.miliexpress.com/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.miliexpress.com/api/graphql', { method: 'POST', headers: { 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, body: JSON.stringify({ query: `mutation DriverAddGpsTackingRecord { driverAddGpsTackingRecord }`, 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 DriverAddGpsTackingRecord {\\n driverAddGpsTackingRecord\\n}\",\"variables\":{}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.miliexpress.com/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.miliexpress.com/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 { driverAddGpsTackingRecord }', variables: {} }) response = http.request(request) puts JSON.parse(response.body)

<?php require 'vendor/autoload.php'; $client = new GuzzleHttp\Client(); $response = $client->post('https://api.miliexpress.com/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":123,"gps_tracking_id":123}', true), ], ]); $data = json_decode($response->getBody(), true); print_r($data);

import requests response = requests.post( 'https://api.miliexpress.com/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":123,"gps_tracking_id":123}, }, ) 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":123,"gps_tracking_id":123}, }) req, _ := http.NewRequest("POST", "https://api.miliexpress.com/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.miliexpress.com/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": 123, "gps_tracking_id": 123 }, }), }); 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\":123,\"gps_tracking_id\":123}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.miliexpress.com/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.miliexpress.com/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":123,"gps_tracking_id":123} }) response = http.request(request) puts JSON.parse(response.body)

<?php require 'vendor/autoload.php'; $client = new GuzzleHttp\Client(); $response = $client->post('https://api.miliexpress.com/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":123,"gps_tracking_id":123}', true), ], ]); $data = json_decode($response->getBody(), true); print_r($data);

import requests response = requests.post( 'https://api.miliexpress.com/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":123,"gps_tracking_id":123}, }, ) 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":123,"gps_tracking_id":123}, }) req, _ := http.NewRequest("POST", "https://api.miliexpress.com/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.miliexpress.com/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": 123, "gps_tracking_id": 123 }, }), }); 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\":123,\"gps_tracking_id\":123}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.miliexpress.com/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.miliexpress.com/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":123,"gps_tracking_id":123} }) response = http.request(request) puts JSON.parse(response.body)

<?php require 'vendor/autoload.php'; $client = new GuzzleHttp\Client(); $response = $client->post('https://api.miliexpress.com/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":123,"ref":"abc"}', true), ], ]); $data = json_decode($response->getBody(), true); print_r($data);

import requests response = requests.post( 'https://api.miliexpress.com/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":123,"ref":"abc"}, }, ) 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":123,"ref":"abc"}, }) req, _ := http.NewRequest("POST", "https://api.miliexpress.com/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.miliexpress.com/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": 123, "ref": "abc" }, }), }); 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\":123,\"ref\":\"abc\"}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.miliexpress.com/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.miliexpress.com/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":123,"ref":"abc"} }) response = http.request(request) puts JSON.parse(response.body)

<?php require 'vendor/autoload.php'; $client = new GuzzleHttp\Client(); $response = $client->post('https://api.miliexpress.com/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":12345,"notes":"this is an example"}', true), ], ]); $data = json_decode($response->getBody(), true); print_r($data);

import requests response = requests.post( 'https://api.miliexpress.com/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":12345,"notes":"this is an 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":12345,"notes":"this is an example"}, }) req, _ := http.NewRequest("POST", "https://api.miliexpress.com/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.miliexpress.com/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": 12345, "notes": "this is an 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\":12345,\"notes\":\"this is an example\"}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.miliexpress.com/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.miliexpress.com/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":12345,"notes":"this is an example"} }) response = http.request(request) puts JSON.parse(response.body)

<?php require 'vendor/autoload.php'; $client = new GuzzleHttp\Client(); $response = $client->post('https://api.miliexpress.com/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) { driverUploadPictures(orderId: $orderId, type: $type, image: $image, imageUrl: $imageUrl, gps_tracking_id: $gps_tracking_id, operation_event_id: $operation_event_id) }', 'variables' => json_decode('{"orderId":12345,"type":"photo","image":"data:image\\/png;base64,iVBORw0KGgoAAAANSUhEUgAAAMgAAADICAYAAACtWK6eAAAAAXN","imageUrl":"http:\\/\\/abc.com\\/a.png","gps_tracking_id":1,"operation_event_id":1}', true), ], ]); $data = json_decode($response->getBody(), true); print_r($data);

import requests response = requests.post( 'https://api.miliexpress.com/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) { driverUploadPictures(orderId: $orderId, type: $type, image: $image, imageUrl: $imageUrl, gps_tracking_id: $gps_tracking_id, operation_event_id: $operation_event_id) }', 'variables': {"orderId":12345,"type":"photo","image":"data:image\/png;base64,iVBORw0KGgoAAAANSUhEUgAAAMgAAADICAYAAACtWK6eAAAAAXN","imageUrl":"http:\/\/abc.com\/a.png","gps_tracking_id":1,"operation_event_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 DriverUploadPictures($orderId: Int, $type: String, $image: String, $imageUrl: String, $gps_tracking_id: Int, $operation_event_id: Int) { driverUploadPictures(orderId: $orderId, type: $type, image: $image, imageUrl: $imageUrl, gps_tracking_id: $gps_tracking_id, operation_event_id: $operation_event_id) }`, "variables": {"orderId":12345,"type":"photo","image":"data:image\/png;base64,iVBORw0KGgoAAAANSUhEUgAAAMgAAADICAYAAACtWK6eAAAAAXN","imageUrl":"http:\/\/abc.com\/a.png","gps_tracking_id":1,"operation_event_id":1}, }) req, _ := http.NewRequest("POST", "https://api.miliexpress.com/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.miliexpress.com/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) { driverUploadPictures(orderId: $orderId, type: $type, image: $image, imageUrl: $imageUrl, gps_tracking_id: $gps_tracking_id, operation_event_id: $operation_event_id) }`, variables: { "orderId": 12345, "type": "photo", "image": "data:image\/png;base64,iVBORw0KGgoAAAANSUhEUgAAAMgAAADICAYAAACtWK6eAAAAAXN", "imageUrl": "http:\/\/abc.com\/a.png", "gps_tracking_id": 1, "operation_event_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 DriverUploadPictures($orderId: Int, $type: String, $image: String, $imageUrl: String, $gps_tracking_id: Int, $operation_event_id: Int) {\\n driverUploadPictures(orderId: $orderId, type: $type, image: $image, imageUrl: $imageUrl, gps_tracking_id: $gps_tracking_id, operation_event_id: $operation_event_id)\\n}\",\"variables\":{\"orderId\":12345,\"type\":\"photo\",\"image\":\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAMgAAADICAYAAACtWK6eAAAAAXN\",\"imageUrl\":\"http://abc.com/a.png\",\"gps_tracking_id\":1,\"operation_event_id\":1}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.miliexpress.com/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.miliexpress.com/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) { driverUploadPictures(orderId: $orderId, type: $type, image: $image, imageUrl: $imageUrl, gps_tracking_id: $gps_tracking_id, operation_event_id: $operation_event_id) }', variables: {"orderId":12345,"type":"photo","image":"data:image\/png;base64,iVBORw0KGgoAAAANSUhEUgAAAMgAAADICAYAAACtWK6eAAAAAXN","imageUrl":"http:\/\/abc.com\/a.png","gps_tracking_id":1,"operation_event_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.miliexpress.com/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":123}', true), ], ]); $data = json_decode($response->getBody(), true); print_r($data);

import requests response = requests.post( 'https://api.miliexpress.com/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":123}, }, ) 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":123}, }) req, _ := http.NewRequest("POST", "https://api.miliexpress.com/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.miliexpress.com/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": 123 }, }), }); 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\":123}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.miliexpress.com/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.miliexpress.com/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":123} }) response = http.request(request) puts JSON.parse(response.body)

<?php require 'vendor/autoload.php'; $client = new GuzzleHttp\Client(); $response = $client->post('https://api.miliexpress.com/api/graphql', [ 'headers' => [ 'Content-Type' => 'application/json', 'Accept' => 'application/json', ], 'json' => [ 'query' => 'mutation DriverRegister($X-BUSINESS-ID: String, $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, $territory_id: Int, $start_location_id: Int, $end_location_id: Int) { driverRegister(X-BUSINESS-ID: $X-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, territory_id: $territory_id, start_location_id: $start_location_id, end_location_id: $end_location_id) }', 'variables' => json_decode('{"X-BUSINESS-ID":"example","alias":"example","name":"example","password":"example","email":"user@example.com","telephone":"example","address":"example","address_2":"example","city":"example","province":"example","country":"example","postcode":"example","language":"example","capacity":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.miliexpress.com/api/graphql', headers={ 'Content-Type': 'application/json', 'Accept': 'application/json', }, json={ 'query': 'mutation DriverRegister($X-BUSINESS-ID: String, $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, $territory_id: Int, $start_location_id: Int, $end_location_id: Int) { driverRegister(X-BUSINESS-ID: $X-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, territory_id: $territory_id, start_location_id: $start_location_id, end_location_id: $end_location_id) }', 'variables': {"X-BUSINESS-ID":"example","alias":"example","name":"example","password":"example","email":"user@example.com","telephone":"example","address":"example","address_2":"example","city":"example","province":"example","country":"example","postcode":"example","language":"example","capacity":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($X-BUSINESS-ID: String, $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, $territory_id: Int, $start_location_id: Int, $end_location_id: Int) { driverRegister(X-BUSINESS-ID: $X-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, territory_id: $territory_id, start_location_id: $start_location_id, end_location_id: $end_location_id) }`, "variables": {"X-BUSINESS-ID":"example","alias":"example","name":"example","password":"example","email":"user@example.com","telephone":"example","address":"example","address_2":"example","city":"example","province":"example","country":"example","postcode":"example","language":"example","capacity":1,"territory_id":1,"start_location_id":1,"end_location_id":1}, }) req, _ := http.NewRequest("POST", "https://api.miliexpress.com/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.miliexpress.com/api/graphql', { method: 'POST', headers: { 'Content-Type': 'application/json', 'Accept': 'application/json', }, body: JSON.stringify({ query: `mutation DriverRegister($X-BUSINESS-ID: String, $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, $territory_id: Int, $start_location_id: Int, $end_location_id: Int) { driverRegister(X-BUSINESS-ID: $X-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, territory_id: $territory_id, start_location_id: $start_location_id, end_location_id: $end_location_id) }`, variables: { "X-BUSINESS-ID": "example", "alias": "example", "name": "example", "password": "example", "email": "user@example.com", "telephone": "example", "address": "example", "address_2": "example", "city": "example", "province": "example", "country": "example", "postcode": "example", "language": "example", "capacity": 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($X-BUSINESS-ID: String, $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, $territory_id: Int, $start_location_id: Int, $end_location_id: Int) {\\n driverRegister(X-BUSINESS-ID: $X-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, territory_id: $territory_id, start_location_id: $start_location_id, end_location_id: $end_location_id)\\n}\",\"variables\":{\"X-BUSINESS-ID\":\"example\",\"alias\":\"example\",\"name\":\"example\",\"password\":\"example\",\"email\":\"user@example.com\",\"telephone\":\"example\",\"address\":\"example\",\"address_2\":\"example\",\"city\":\"example\",\"province\":\"example\",\"country\":\"example\",\"postcode\":\"example\",\"language\":\"example\",\"capacity\":1,\"territory_id\":1,\"start_location_id\":1,\"end_location_id\":1}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.miliexpress.com/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.miliexpress.com/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($X-BUSINESS-ID: String, $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, $territory_id: Int, $start_location_id: Int, $end_location_id: Int) { driverRegister(X-BUSINESS-ID: $X-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, territory_id: $territory_id, start_location_id: $start_location_id, end_location_id: $end_location_id) }', variables: {"X-BUSINESS-ID":"example","alias":"example","name":"example","password":"example","email":"user@example.com","telephone":"example","address":"example","address_2":"example","city":"example","province":"example","country":"example","postcode":"example","language":"example","capacity":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.miliexpress.com/api/graphql', [ 'headers' => [ 'Content-Type' => 'application/json', 'Accept' => 'application/json', 'Authorization' => 'Bearer YOUR_TOKEN', ], 'json' => [ 'query' => 'mutation DriverOptimizeRoute($async: Boolean, $routeId: Int, $driverAddresses: String) { driverOptimizeRoute(async: $async, routeId: $routeId, driverAddresses: $driverAddresses) }', 'variables' => json_decode('{"async":true,"routeId":123,"driverAddresses":{"start_address_id":1001,"start_address":{"name":"Warehouse A","lat":43.65107,"lng":-79.347015},"end_address_id":1002,"end_address":{"name":"Dropoff Point Z","address_1":"456 King St","city":"Toronto","province":"ON","country":"CA","postcode":"M5V1K1"}}}', true), ], ]); $data = json_decode($response->getBody(), true); print_r($data);

import requests response = requests.post( 'https://api.miliexpress.com/api/graphql', headers={ 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, json={ 'query': 'mutation DriverOptimizeRoute($async: Boolean, $routeId: Int, $driverAddresses: String) { driverOptimizeRoute(async: $async, routeId: $routeId, driverAddresses: $driverAddresses) }', 'variables': {"async":true,"routeId":123,"driverAddresses":{"start_address_id":1001,"start_address":{"name":"Warehouse A","lat":43.65107,"lng":-79.347015},"end_address_id":1002,"end_address":{"name":"Dropoff Point Z","address_1":"456 King St","city":"Toronto","province":"ON","country":"CA","postcode":"M5V1K1"}}}, }, ) 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: String) { driverOptimizeRoute(async: $async, routeId: $routeId, driverAddresses: $driverAddresses) }`, "variables": {"async":true,"routeId":123,"driverAddresses":{"start_address_id":1001,"start_address":{"name":"Warehouse A","lat":43.65107,"lng":-79.347015},"end_address_id":1002,"end_address":{"name":"Dropoff Point Z","address_1":"456 King St","city":"Toronto","province":"ON","country":"CA","postcode":"M5V1K1"}}}, }) req, _ := http.NewRequest("POST", "https://api.miliexpress.com/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.miliexpress.com/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: String) { driverOptimizeRoute(async: $async, routeId: $routeId, driverAddresses: $driverAddresses) }`, variables: { "async": true, "routeId": 123, "driverAddresses": { "start_address_id": 1001, "start_address": { "name": "Warehouse A", "lat": 43.65107, "lng": -79.347015 }, "end_address_id": 1002, "end_address": { "name": "Dropoff Point Z", "address_1": "456 King St", "city": "Toronto", "province": "ON", "country": "CA", "postcode": "M5V1K1" } } }, }), }); 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: String) {\\n driverOptimizeRoute(async: $async, routeId: $routeId, driverAddresses: $driverAddresses)\\n}\",\"variables\":{\"async\":true,\"routeId\":123,\"driverAddresses\":{\"start_address_id\":1001,\"start_address\":{\"name\":\"Warehouse A\",\"lat\":43.65107,\"lng\":-79.347015},\"end_address_id\":1002,\"end_address\":{\"name\":\"Dropoff Point Z\",\"address_1\":\"456 King St\",\"city\":\"Toronto\",\"province\":\"ON\",\"country\":\"CA\",\"postcode\":\"M5V1K1\"}}}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.miliexpress.com/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.miliexpress.com/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: String) { driverOptimizeRoute(async: $async, routeId: $routeId, driverAddresses: $driverAddresses) }', variables: {"async":true,"routeId":123,"driverAddresses":{"start_address_id":1001,"start_address":{"name":"Warehouse A","lat":43.65107,"lng":-79.347015},"end_address_id":1002,"end_address":{"name":"Dropoff Point Z","address_1":"456 King St","city":"Toronto","province":"ON","country":"CA","postcode":"M5V1K1"}}} }) response = http.request(request) puts JSON.parse(response.body)

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

import requests response = requests.post( 'https://api.miliexpress.com/api/graphql', headers={ 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, json={ 'query': 'mutation DriverProfile { driverProfile }', '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 DriverProfile { driverProfile }`, "variables": map[string]interface{}{}, }) req, _ := http.NewRequest("POST", "https://api.miliexpress.com/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.miliexpress.com/api/graphql', { method: 'POST', headers: { 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, body: JSON.stringify({ query: `mutation DriverProfile { driverProfile }`, 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 DriverProfile {\\n driverProfile\\n}\",\"variables\":{}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.miliexpress.com/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.miliexpress.com/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 { driverProfile }', variables: {} }) response = http.request(request) puts JSON.parse(response.body)

<?php require 'vendor/autoload.php'; $client = new GuzzleHttp\Client(); $response = $client->post('https://api.miliexpress.com/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":100,"order_id":5000,"scan_code":"ABC123"}', true), ], ]); $data = json_decode($response->getBody(), true); print_r($data);

import requests response = requests.post( 'https://api.miliexpress.com/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":100,"order_id":5000,"scan_code":"ABC123"}, }, ) 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":100,"order_id":5000,"scan_code":"ABC123"}, }) req, _ := http.NewRequest("POST", "https://api.miliexpress.com/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.miliexpress.com/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": 100, "order_id": 5000, "scan_code": "ABC123" }, }), }); 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\":100,\"order_id\":5000,\"scan_code\":\"ABC123\"}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.miliexpress.com/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.miliexpress.com/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":100,"order_id":5000,"scan_code":"ABC123"} }) response = http.request(request) puts JSON.parse(response.body)

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

import requests response = requests.post( 'https://api.miliexpress.com/api/graphql', headers={ 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, json={ 'query': 'mutation DriverUpdateFcmToken($fcm_token: String) { driverUpdateFcmToken(fcm_token: $fcm_token) }', 'variables': {"fcm_token":"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) { driverUpdateFcmToken(fcm_token: $fcm_token) }`, "variables": {"fcm_token":"example"}, }) req, _ := http.NewRequest("POST", "https://api.miliexpress.com/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.miliexpress.com/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) { driverUpdateFcmToken(fcm_token: $fcm_token) }`, variables: { "fcm_token": "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) {\\n driverUpdateFcmToken(fcm_token: $fcm_token)\\n}\",\"variables\":{\"fcm_token\":\"example\"}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.miliexpress.com/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.miliexpress.com/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) { driverUpdateFcmToken(fcm_token: $fcm_token) }', variables: {"fcm_token":"example"} }) response = http.request(request) puts JSON.parse(response.body)

<?php require 'vendor/autoload.php'; $client = new GuzzleHttp\Client(); $response = $client->post('https://api.miliexpress.com/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.miliexpress.com/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.miliexpress.com/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.miliexpress.com/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.miliexpress.com/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.miliexpress.com/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.miliexpress.com/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.miliexpress.com/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.miliexpress.com/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.miliexpress.com/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.miliexpress.com/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.miliexpress.com/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.miliexpress.com/api/graphql', [ 'headers' => [ 'Content-Type' => 'application/json', 'Accept' => 'application/json', 'Authorization' => 'Bearer YOUR_TOKEN', ], 'json' => [ 'query' => 'mutation DriverUpdateDeliver($order_id: Int, $captured_at: String) { driverUpdateDeliver(order_id: $order_id, captured_at: $captured_at) }', 'variables' => json_decode('{"order_id":1,"captured_at":"2026-03-12T14:30:00+08:00"}', true), ], ]); $data = json_decode($response->getBody(), true); print_r($data);

import requests response = requests.post( 'https://api.miliexpress.com/api/graphql', headers={ 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, json={ 'query': 'mutation DriverUpdateDeliver($order_id: Int, $captured_at: String) { driverUpdateDeliver(order_id: $order_id, captured_at: $captured_at) }', 'variables': {"order_id":1,"captured_at":"2026-03-12T14:30:00+08:00"}, }, ) 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($order_id: Int, $captured_at: String) { driverUpdateDeliver(order_id: $order_id, captured_at: $captured_at) }`, "variables": {"order_id":1,"captured_at":"2026-03-12T14:30:00+08:00"}, }) req, _ := http.NewRequest("POST", "https://api.miliexpress.com/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.miliexpress.com/api/graphql', { method: 'POST', headers: { 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, body: JSON.stringify({ query: `mutation DriverUpdateDeliver($order_id: Int, $captured_at: String) { driverUpdateDeliver(order_id: $order_id, captured_at: $captured_at) }`, variables: { "order_id": 1, "captured_at": "2026-03-12T14:30:00+08:00" }, }), }); 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($order_id: Int, $captured_at: String) {\\n driverUpdateDeliver(order_id: $order_id, captured_at: $captured_at)\\n}\",\"variables\":{\"order_id\":1,\"captured_at\":\"2026-03-12T14:30:00+08:00\"}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.miliexpress.com/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.miliexpress.com/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($order_id: Int, $captured_at: String) { driverUpdateDeliver(order_id: $order_id, captured_at: $captured_at) }', variables: {"order_id":1,"captured_at":"2026-03-12T14:30:00+08:00"} }) response = http.request(request) puts JSON.parse(response.body)

<?php require 'vendor/autoload.php'; $client = new GuzzleHttp\Client(); $response = $client->post('https://api.miliexpress.com/api/graphql', [ 'headers' => [ 'Content-Type' => 'application/json', 'Accept' => 'application/json', 'Authorization' => 'Bearer YOUR_TOKEN', ], 'json' => [ 'query' => 'mutation DriverBatchUpdateDeliver($orders: [String], $captured_at: String) { driverBatchUpdateDeliver(orders: $orders, captured_at: $captured_at) }', 'variables' => json_decode('{"captured_at":"2026-03-12T14:30:00+08:00"}', true), ], ]); $data = json_decode($response->getBody(), true); print_r($data);

import requests response = requests.post( 'https://api.miliexpress.com/api/graphql', headers={ 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, json={ 'query': 'mutation DriverBatchUpdateDeliver($orders: [String], $captured_at: String) { driverBatchUpdateDeliver(orders: $orders, captured_at: $captured_at) }', 'variables': {"captured_at":"2026-03-12T14:30:00+08:00"}, }, ) 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($orders: [String], $captured_at: String) { driverBatchUpdateDeliver(orders: $orders, captured_at: $captured_at) }`, "variables": {"captured_at":"2026-03-12T14:30:00+08:00"}, }) req, _ := http.NewRequest("POST", "https://api.miliexpress.com/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.miliexpress.com/api/graphql', { method: 'POST', headers: { 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, body: JSON.stringify({ query: `mutation DriverBatchUpdateDeliver($orders: [String], $captured_at: String) { driverBatchUpdateDeliver(orders: $orders, captured_at: $captured_at) }`, variables: { "captured_at": "2026-03-12T14:30:00+08:00" }, }), }); 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($orders: [String], $captured_at: String) {\\n driverBatchUpdateDeliver(orders: $orders, captured_at: $captured_at)\\n}\",\"variables\":{\"captured_at\":\"2026-03-12T14:30:00+08:00\"}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.miliexpress.com/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.miliexpress.com/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($orders: [String], $captured_at: String) { driverBatchUpdateDeliver(orders: $orders, captured_at: $captured_at) }', variables: {"captured_at":"2026-03-12T14:30:00+08:00"} }) response = http.request(request) puts JSON.parse(response.body)

<?php require 'vendor/autoload.php'; $client = new GuzzleHttp\Client(); $response = $client->post('https://api.miliexpress.com/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.miliexpress.com/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.miliexpress.com/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.miliexpress.com/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.miliexpress.com/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.miliexpress.com/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.miliexpress.com/api/graphql', [ 'headers' => [ 'Content-Type' => 'application/json', 'Accept' => 'application/json', 'Authorization' => 'Bearer YOUR_TOKEN', ], 'json' => [ 'query' => 'mutation ClientOrderCreate($postcode: String, $street_number: String, $street_name: String, $apt: String, $buzz_code: String, $ref: String, $city: String, $province: String, $country: String, $name: String, $email: String, $telephone: String, $note: String, $notification_language: String, $need_pick_up: Int, $surcharges: [String]) { clientOrderCreate(postcode: $postcode, street_number: $street_number, street_name: $street_name, apt: $apt, buzz_code: $buzz_code, ref: $ref, city: $city, province: $province, country: $country, name: $name, email: $email, telephone: $telephone, note: $note, notification_language: $notification_language, need_pick_up: $need_pick_up, surcharges: $surcharges) }', 'variables' => json_decode('{"postcode":"H9S2H9","street_number":"2667","street_name":"boul des sources","apt":"123","buzz_code":"9393","ref":"altima-4","city":"pointe-claire","province":"QC","country":"Canada","name":"John","email":"join@gmail.com","telephone":"5555555555","note":"customer note","notification_language":"en","need_pick_up":"0 (no) or 1 (need pickup) or 2 (Inbound scan required) or 3 (need batch pickup)","surcharges":["{\\"code\\": 1, \\"selected_values\\": [1]}","{\\"code\\": 2, \\"selected_values\\": [\\"0\\"]}"]}', true), ], ]); $data = json_decode($response->getBody(), true); print_r($data);

import requests response = requests.post( 'https://api.miliexpress.com/api/graphql', headers={ 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, json={ 'query': 'mutation ClientOrderCreate($postcode: String, $street_number: String, $street_name: String, $apt: String, $buzz_code: String, $ref: String, $city: String, $province: String, $country: String, $name: String, $email: String, $telephone: String, $note: String, $notification_language: String, $need_pick_up: Int, $surcharges: [String]) { clientOrderCreate(postcode: $postcode, street_number: $street_number, street_name: $street_name, apt: $apt, buzz_code: $buzz_code, ref: $ref, city: $city, province: $province, country: $country, name: $name, email: $email, telephone: $telephone, note: $note, notification_language: $notification_language, need_pick_up: $need_pick_up, surcharges: $surcharges) }', 'variables': {"postcode":"H9S2H9","street_number":"2667","street_name":"boul des sources","apt":"123","buzz_code":"9393","ref":"altima-4","city":"pointe-claire","province":"QC","country":"Canada","name":"John","email":"join@gmail.com","telephone":"5555555555","note":"customer note","notification_language":"en","need_pick_up":"0 (no) or 1 (need pickup) or 2 (Inbound scan required) or 3 (need batch pickup)","surcharges":["{\"code\": 1, \"selected_values\": [1]}","{\"code\": 2, \"selected_values\": [\"0\"]}"]}, }, ) 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($postcode: String, $street_number: String, $street_name: String, $apt: String, $buzz_code: String, $ref: String, $city: String, $province: String, $country: String, $name: String, $email: String, $telephone: String, $note: String, $notification_language: String, $need_pick_up: Int, $surcharges: [String]) { clientOrderCreate(postcode: $postcode, street_number: $street_number, street_name: $street_name, apt: $apt, buzz_code: $buzz_code, ref: $ref, city: $city, province: $province, country: $country, name: $name, email: $email, telephone: $telephone, note: $note, notification_language: $notification_language, need_pick_up: $need_pick_up, surcharges: $surcharges) }`, "variables": {"postcode":"H9S2H9","street_number":"2667","street_name":"boul des sources","apt":"123","buzz_code":"9393","ref":"altima-4","city":"pointe-claire","province":"QC","country":"Canada","name":"John","email":"join@gmail.com","telephone":"5555555555","note":"customer note","notification_language":"en","need_pick_up":"0 (no) or 1 (need pickup) or 2 (Inbound scan required) or 3 (need batch pickup)","surcharges":["{\"code\": 1, \"selected_values\": [1]}","{\"code\": 2, \"selected_values\": [\"0\"]}"]}, }) req, _ := http.NewRequest("POST", "https://api.miliexpress.com/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.miliexpress.com/api/graphql', { method: 'POST', headers: { 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, body: JSON.stringify({ query: `mutation ClientOrderCreate($postcode: String, $street_number: String, $street_name: String, $apt: String, $buzz_code: String, $ref: String, $city: String, $province: String, $country: String, $name: String, $email: String, $telephone: String, $note: String, $notification_language: String, $need_pick_up: Int, $surcharges: [String]) { clientOrderCreate(postcode: $postcode, street_number: $street_number, street_name: $street_name, apt: $apt, buzz_code: $buzz_code, ref: $ref, city: $city, province: $province, country: $country, name: $name, email: $email, telephone: $telephone, note: $note, notification_language: $notification_language, need_pick_up: $need_pick_up, surcharges: $surcharges) }`, variables: { "postcode": "H9S2H9", "street_number": "2667", "street_name": "boul des sources", "apt": "123", "buzz_code": "9393", "ref": "altima-4", "city": "pointe-claire", "province": "QC", "country": "Canada", "name": "John", "email": "join@gmail.com", "telephone": "5555555555", "note": "customer note", "notification_language": "en", "need_pick_up": "0 (no) or 1 (need pickup) or 2 (Inbound scan required) or 3 (need batch pickup)", "surcharges": [ "{\"code\": 1, \"selected_values\": [1]}", "{\"code\": 2, \"selected_values\": [\"0\"]}" ] }, }), }); 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($postcode: String, $street_number: String, $street_name: String, $apt: String, $buzz_code: String, $ref: String, $city: String, $province: String, $country: String, $name: String, $email: String, $telephone: String, $note: String, $notification_language: String, $need_pick_up: Int, $surcharges: [String]) {\\n clientOrderCreate(postcode: $postcode, street_number: $street_number, street_name: $street_name, apt: $apt, buzz_code: $buzz_code, ref: $ref, city: $city, province: $province, country: $country, name: $name, email: $email, telephone: $telephone, note: $note, notification_language: $notification_language, need_pick_up: $need_pick_up, surcharges: $surcharges)\\n}\",\"variables\":{\"postcode\":\"H9S2H9\",\"street_number\":\"2667\",\"street_name\":\"boul des sources\",\"apt\":\"123\",\"buzz_code\":\"9393\",\"ref\":\"altima-4\",\"city\":\"pointe-claire\",\"province\":\"QC\",\"country\":\"Canada\",\"name\":\"John\",\"email\":\"join@gmail.com\",\"telephone\":\"5555555555\",\"note\":\"customer note\",\"notification_language\":\"en\",\"need_pick_up\":\"0 (no) or 1 (need pickup) or 2 (Inbound scan required) or 3 (need batch pickup)\",\"surcharges\":[\"{\\\"code\\\": 1, \\\"selected_values\\\": [1]}\",\"{\\\"code\\\": 2, \\\"selected_values\\\": [\\\"0\\\"]}\"]}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.miliexpress.com/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.miliexpress.com/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($postcode: String, $street_number: String, $street_name: String, $apt: String, $buzz_code: String, $ref: String, $city: String, $province: String, $country: String, $name: String, $email: String, $telephone: String, $note: String, $notification_language: String, $need_pick_up: Int, $surcharges: [String]) { clientOrderCreate(postcode: $postcode, street_number: $street_number, street_name: $street_name, apt: $apt, buzz_code: $buzz_code, ref: $ref, city: $city, province: $province, country: $country, name: $name, email: $email, telephone: $telephone, note: $note, notification_language: $notification_language, need_pick_up: $need_pick_up, surcharges: $surcharges) }', variables: {"postcode":"H9S2H9","street_number":"2667","street_name":"boul des sources","apt":"123","buzz_code":"9393","ref":"altima-4","city":"pointe-claire","province":"QC","country":"Canada","name":"John","email":"join@gmail.com","telephone":"5555555555","note":"customer note","notification_language":"en","need_pick_up":"0 (no) or 1 (need pickup) or 2 (Inbound scan required) or 3 (need batch pickup)","surcharges":["{\"code\": 1, \"selected_values\": [1]}","{\"code\": 2, \"selected_values\": [\"0\"]}"]} }) response = http.request(request) puts JSON.parse(response.body)

<?php require 'vendor/autoload.php'; $client = new GuzzleHttp\Client(); $response = $client->post('https://api.miliexpress.com/api/graphql', [ 'headers' => [ 'Content-Type' => 'application/json', 'Accept' => 'application/json', 'Authorization' => 'Bearer YOUR_TOKEN', ], 'json' => [ 'query' => 'mutation ClientBatchOrderCreate($postcode: String, $street_number: String, $street_name: String, $apt: String, $buzz_code: String, $ref: String, $city: String, $province: String, $country: String, $name: String, $email: String, $telephone: String, $note: String, $notification_language: String, $need_pick_up: Int) { clientBatchOrderCreate(postcode: $postcode, street_number: $street_number, street_name: $street_name, apt: $apt, buzz_code: $buzz_code, ref: $ref, city: $city, province: $province, country: $country, name: $name, email: $email, telephone: $telephone, note: $note, notification_language: $notification_language, need_pick_up: $need_pick_up) }', 'variables' => json_decode('{"postcode":"H9S2H9","street_number":"2667","street_name":"boul des sources","apt":"123","buzz_code":"9393","ref":"altima-4","city":"pointe-claire","province":"QC","country":"Canada","name":"John","email":"join@gmail.com","telephone":"5555555555","note":"customer note","notification_language":"en","need_pick_up":"0 (no) or 1 (need pickup) or 2 (Inbound scan required) or 3 (need batch pickup)"}', true), ], ]); $data = json_decode($response->getBody(), true); print_r($data);

import requests response = requests.post( 'https://api.miliexpress.com/api/graphql', headers={ 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, json={ 'query': 'mutation ClientBatchOrderCreate($postcode: String, $street_number: String, $street_name: String, $apt: String, $buzz_code: String, $ref: String, $city: String, $province: String, $country: String, $name: String, $email: String, $telephone: String, $note: String, $notification_language: String, $need_pick_up: Int) { clientBatchOrderCreate(postcode: $postcode, street_number: $street_number, street_name: $street_name, apt: $apt, buzz_code: $buzz_code, ref: $ref, city: $city, province: $province, country: $country, name: $name, email: $email, telephone: $telephone, note: $note, notification_language: $notification_language, need_pick_up: $need_pick_up) }', 'variables': {"postcode":"H9S2H9","street_number":"2667","street_name":"boul des sources","apt":"123","buzz_code":"9393","ref":"altima-4","city":"pointe-claire","province":"QC","country":"Canada","name":"John","email":"join@gmail.com","telephone":"5555555555","note":"customer note","notification_language":"en","need_pick_up":"0 (no) or 1 (need pickup) or 2 (Inbound scan required) or 3 (need batch pickup)"}, }, ) 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($postcode: String, $street_number: String, $street_name: String, $apt: String, $buzz_code: String, $ref: String, $city: String, $province: String, $country: String, $name: String, $email: String, $telephone: String, $note: String, $notification_language: String, $need_pick_up: Int) { clientBatchOrderCreate(postcode: $postcode, street_number: $street_number, street_name: $street_name, apt: $apt, buzz_code: $buzz_code, ref: $ref, city: $city, province: $province, country: $country, name: $name, email: $email, telephone: $telephone, note: $note, notification_language: $notification_language, need_pick_up: $need_pick_up) }`, "variables": {"postcode":"H9S2H9","street_number":"2667","street_name":"boul des sources","apt":"123","buzz_code":"9393","ref":"altima-4","city":"pointe-claire","province":"QC","country":"Canada","name":"John","email":"join@gmail.com","telephone":"5555555555","note":"customer note","notification_language":"en","need_pick_up":"0 (no) or 1 (need pickup) or 2 (Inbound scan required) or 3 (need batch pickup)"}, }) req, _ := http.NewRequest("POST", "https://api.miliexpress.com/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.miliexpress.com/api/graphql', { method: 'POST', headers: { 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, body: JSON.stringify({ query: `mutation ClientBatchOrderCreate($postcode: String, $street_number: String, $street_name: String, $apt: String, $buzz_code: String, $ref: String, $city: String, $province: String, $country: String, $name: String, $email: String, $telephone: String, $note: String, $notification_language: String, $need_pick_up: Int) { clientBatchOrderCreate(postcode: $postcode, street_number: $street_number, street_name: $street_name, apt: $apt, buzz_code: $buzz_code, ref: $ref, city: $city, province: $province, country: $country, name: $name, email: $email, telephone: $telephone, note: $note, notification_language: $notification_language, need_pick_up: $need_pick_up) }`, variables: { "postcode": "H9S2H9", "street_number": "2667", "street_name": "boul des sources", "apt": "123", "buzz_code": "9393", "ref": "altima-4", "city": "pointe-claire", "province": "QC", "country": "Canada", "name": "John", "email": "join@gmail.com", "telephone": "5555555555", "note": "customer note", "notification_language": "en", "need_pick_up": "0 (no) or 1 (need pickup) or 2 (Inbound scan required) or 3 (need batch pickup)" }, }), }); 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($postcode: String, $street_number: String, $street_name: String, $apt: String, $buzz_code: String, $ref: String, $city: String, $province: String, $country: String, $name: String, $email: String, $telephone: String, $note: String, $notification_language: String, $need_pick_up: Int) {\\n clientBatchOrderCreate(postcode: $postcode, street_number: $street_number, street_name: $street_name, apt: $apt, buzz_code: $buzz_code, ref: $ref, city: $city, province: $province, country: $country, name: $name, email: $email, telephone: $telephone, note: $note, notification_language: $notification_language, need_pick_up: $need_pick_up)\\n}\",\"variables\":{\"postcode\":\"H9S2H9\",\"street_number\":\"2667\",\"street_name\":\"boul des sources\",\"apt\":\"123\",\"buzz_code\":\"9393\",\"ref\":\"altima-4\",\"city\":\"pointe-claire\",\"province\":\"QC\",\"country\":\"Canada\",\"name\":\"John\",\"email\":\"join@gmail.com\",\"telephone\":\"5555555555\",\"note\":\"customer note\",\"notification_language\":\"en\",\"need_pick_up\":\"0 (no) or 1 (need pickup) or 2 (Inbound scan required) or 3 (need batch pickup)\"}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.miliexpress.com/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.miliexpress.com/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($postcode: String, $street_number: String, $street_name: String, $apt: String, $buzz_code: String, $ref: String, $city: String, $province: String, $country: String, $name: String, $email: String, $telephone: String, $note: String, $notification_language: String, $need_pick_up: Int) { clientBatchOrderCreate(postcode: $postcode, street_number: $street_number, street_name: $street_name, apt: $apt, buzz_code: $buzz_code, ref: $ref, city: $city, province: $province, country: $country, name: $name, email: $email, telephone: $telephone, note: $note, notification_language: $notification_language, need_pick_up: $need_pick_up) }', variables: {"postcode":"H9S2H9","street_number":"2667","street_name":"boul des sources","apt":"123","buzz_code":"9393","ref":"altima-4","city":"pointe-claire","province":"QC","country":"Canada","name":"John","email":"join@gmail.com","telephone":"5555555555","note":"customer note","notification_language":"en","need_pick_up":"0 (no) or 1 (need pickup) or 2 (Inbound scan required) or 3 (need batch pickup)"} }) response = http.request(request) puts JSON.parse(response.body)

<?php require 'vendor/autoload.php'; $client = new GuzzleHttp\Client(); $response = $client->post('https://api.miliexpress.com/api/graphql', [ 'headers' => [ 'Content-Type' => 'application/json', 'Accept' => 'application/json', 'Authorization' => 'Bearer YOUR_TOKEN', ], 'json' => [ 'query' => 'mutation ClientBatchOrderCreateAsync($postcode: String, $street_number: String, $street_name: String, $apt: String, $buzz_code: String, $ref: String, $city: String, $province: String, $country: String, $name: String, $email: String, $telephone: String, $note: String, $notification_language: String, $need_pick_up: Int) { clientBatchOrderCreateAsync(postcode: $postcode, street_number: $street_number, street_name: $street_name, apt: $apt, buzz_code: $buzz_code, ref: $ref, city: $city, province: $province, country: $country, name: $name, email: $email, telephone: $telephone, note: $note, notification_language: $notification_language, need_pick_up: $need_pick_up) }', 'variables' => json_decode('{"postcode":"H9S2H9","street_number":"2667","street_name":"boul des sources","apt":"123","buzz_code":"9393","ref":"altima-4","city":"pointe-claire","province":"QC","country":"Canada","name":"John","email":"join@gmail.com","telephone":"5555555555","note":"customer note","notification_language":"en","need_pick_up":"0 (no) or 1 (need pickup) or 2 (Inbound scan required) or 3 (need batch pickup)"}', true), ], ]); $data = json_decode($response->getBody(), true); print_r($data);

import requests response = requests.post( 'https://api.miliexpress.com/api/graphql', headers={ 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, json={ 'query': 'mutation ClientBatchOrderCreateAsync($postcode: String, $street_number: String, $street_name: String, $apt: String, $buzz_code: String, $ref: String, $city: String, $province: String, $country: String, $name: String, $email: String, $telephone: String, $note: String, $notification_language: String, $need_pick_up: Int) { clientBatchOrderCreateAsync(postcode: $postcode, street_number: $street_number, street_name: $street_name, apt: $apt, buzz_code: $buzz_code, ref: $ref, city: $city, province: $province, country: $country, name: $name, email: $email, telephone: $telephone, note: $note, notification_language: $notification_language, need_pick_up: $need_pick_up) }', 'variables': {"postcode":"H9S2H9","street_number":"2667","street_name":"boul des sources","apt":"123","buzz_code":"9393","ref":"altima-4","city":"pointe-claire","province":"QC","country":"Canada","name":"John","email":"join@gmail.com","telephone":"5555555555","note":"customer note","notification_language":"en","need_pick_up":"0 (no) or 1 (need pickup) or 2 (Inbound scan required) or 3 (need batch pickup)"}, }, ) 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($postcode: String, $street_number: String, $street_name: String, $apt: String, $buzz_code: String, $ref: String, $city: String, $province: String, $country: String, $name: String, $email: String, $telephone: String, $note: String, $notification_language: String, $need_pick_up: Int) { clientBatchOrderCreateAsync(postcode: $postcode, street_number: $street_number, street_name: $street_name, apt: $apt, buzz_code: $buzz_code, ref: $ref, city: $city, province: $province, country: $country, name: $name, email: $email, telephone: $telephone, note: $note, notification_language: $notification_language, need_pick_up: $need_pick_up) }`, "variables": {"postcode":"H9S2H9","street_number":"2667","street_name":"boul des sources","apt":"123","buzz_code":"9393","ref":"altima-4","city":"pointe-claire","province":"QC","country":"Canada","name":"John","email":"join@gmail.com","telephone":"5555555555","note":"customer note","notification_language":"en","need_pick_up":"0 (no) or 1 (need pickup) or 2 (Inbound scan required) or 3 (need batch pickup)"}, }) req, _ := http.NewRequest("POST", "https://api.miliexpress.com/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.miliexpress.com/api/graphql', { method: 'POST', headers: { 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, body: JSON.stringify({ query: `mutation ClientBatchOrderCreateAsync($postcode: String, $street_number: String, $street_name: String, $apt: String, $buzz_code: String, $ref: String, $city: String, $province: String, $country: String, $name: String, $email: String, $telephone: String, $note: String, $notification_language: String, $need_pick_up: Int) { clientBatchOrderCreateAsync(postcode: $postcode, street_number: $street_number, street_name: $street_name, apt: $apt, buzz_code: $buzz_code, ref: $ref, city: $city, province: $province, country: $country, name: $name, email: $email, telephone: $telephone, note: $note, notification_language: $notification_language, need_pick_up: $need_pick_up) }`, variables: { "postcode": "H9S2H9", "street_number": "2667", "street_name": "boul des sources", "apt": "123", "buzz_code": "9393", "ref": "altima-4", "city": "pointe-claire", "province": "QC", "country": "Canada", "name": "John", "email": "join@gmail.com", "telephone": "5555555555", "note": "customer note", "notification_language": "en", "need_pick_up": "0 (no) or 1 (need pickup) or 2 (Inbound scan required) or 3 (need batch pickup)" }, }), }); 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($postcode: String, $street_number: String, $street_name: String, $apt: String, $buzz_code: String, $ref: String, $city: String, $province: String, $country: String, $name: String, $email: String, $telephone: String, $note: String, $notification_language: String, $need_pick_up: Int) {\\n clientBatchOrderCreateAsync(postcode: $postcode, street_number: $street_number, street_name: $street_name, apt: $apt, buzz_code: $buzz_code, ref: $ref, city: $city, province: $province, country: $country, name: $name, email: $email, telephone: $telephone, note: $note, notification_language: $notification_language, need_pick_up: $need_pick_up)\\n}\",\"variables\":{\"postcode\":\"H9S2H9\",\"street_number\":\"2667\",\"street_name\":\"boul des sources\",\"apt\":\"123\",\"buzz_code\":\"9393\",\"ref\":\"altima-4\",\"city\":\"pointe-claire\",\"province\":\"QC\",\"country\":\"Canada\",\"name\":\"John\",\"email\":\"join@gmail.com\",\"telephone\":\"5555555555\",\"note\":\"customer note\",\"notification_language\":\"en\",\"need_pick_up\":\"0 (no) or 1 (need pickup) or 2 (Inbound scan required) or 3 (need batch pickup)\"}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.miliexpress.com/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.miliexpress.com/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($postcode: String, $street_number: String, $street_name: String, $apt: String, $buzz_code: String, $ref: String, $city: String, $province: String, $country: String, $name: String, $email: String, $telephone: String, $note: String, $notification_language: String, $need_pick_up: Int) { clientBatchOrderCreateAsync(postcode: $postcode, street_number: $street_number, street_name: $street_name, apt: $apt, buzz_code: $buzz_code, ref: $ref, city: $city, province: $province, country: $country, name: $name, email: $email, telephone: $telephone, note: $note, notification_language: $notification_language, need_pick_up: $need_pick_up) }', variables: {"postcode":"H9S2H9","street_number":"2667","street_name":"boul des sources","apt":"123","buzz_code":"9393","ref":"altima-4","city":"pointe-claire","province":"QC","country":"Canada","name":"John","email":"join@gmail.com","telephone":"5555555555","note":"customer note","notification_language":"en","need_pick_up":"0 (no) or 1 (need pickup) or 2 (Inbound scan required) or 3 (need batch pickup)"} }) response = http.request(request) puts JSON.parse(response.body)

<?php require 'vendor/autoload.php'; $client = new GuzzleHttp\Client(); $response = $client->post('https://api.miliexpress.com/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, $serve_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) { clientBuildRoute(drivers: $drivers, route_name: $route_name, route_date: $route_date, serve_time: $serve_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) }', 'variables' => json_decode('{"drivers":[1],"route_name":"test","route_date":"2021-03-14","serve_time":3,"pickup_time":3,"package_processing_time":30,"package_pickup_time":30,"order_number":200,"balance_mode":1,"territory_id":"1 (for multiple territory user)","order_type":"D,P,DP,DD,P2P (D:Delivery P:Pickup,DP:Pickup Step,DD:Delivery Step,P2P:Peer to Peer)","order_batch":"W1,W2,W3","sorting_code":"123,234,221","label_code":"X2,X3,X4","warehouse_id":12,"start_address_1":3,"end_address_1":2,"region_group_1":"4 (for multiple territory user)","start_time_1":"9:00","end_time_1":"17:00","max_distance":120,"vehicle_type":"1 (1: Car, 2: Truck, 3: Motorcycle, 4: Bicycle 5:Pedestrian nullable,default 1)"}', true), ], ]); $data = json_decode($response->getBody(), true); print_r($data);

import requests response = requests.post( 'https://api.miliexpress.com/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, $serve_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) { clientBuildRoute(drivers: $drivers, route_name: $route_name, route_date: $route_date, serve_time: $serve_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) }', 'variables': {"drivers":[1],"route_name":"test","route_date":"2021-03-14","serve_time":3,"pickup_time":3,"package_processing_time":30,"package_pickup_time":30,"order_number":200,"balance_mode":1,"territory_id":"1 (for multiple territory user)","order_type":"D,P,DP,DD,P2P (D:Delivery P:Pickup,DP:Pickup Step,DD:Delivery Step,P2P:Peer to Peer)","order_batch":"W1,W2,W3","sorting_code":"123,234,221","label_code":"X2,X3,X4","warehouse_id":12,"start_address_1":3,"end_address_1":2,"region_group_1":"4 (for multiple territory user)","start_time_1":"9:00","end_time_1":"17:00","max_distance":120,"vehicle_type":"1 (1: Car, 2: Truck, 3: Motorcycle, 4: Bicycle 5:Pedestrian nullable,default 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 ClientBuildRoute($drivers: [String], $route_name: String, $route_date: String, $serve_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) { clientBuildRoute(drivers: $drivers, route_name: $route_name, route_date: $route_date, serve_time: $serve_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) }`, "variables": {"drivers":[1],"route_name":"test","route_date":"2021-03-14","serve_time":3,"pickup_time":3,"package_processing_time":30,"package_pickup_time":30,"order_number":200,"balance_mode":1,"territory_id":"1 (for multiple territory user)","order_type":"D,P,DP,DD,P2P (D:Delivery P:Pickup,DP:Pickup Step,DD:Delivery Step,P2P:Peer to Peer)","order_batch":"W1,W2,W3","sorting_code":"123,234,221","label_code":"X2,X3,X4","warehouse_id":12,"start_address_1":3,"end_address_1":2,"region_group_1":"4 (for multiple territory user)","start_time_1":"9:00","end_time_1":"17:00","max_distance":120,"vehicle_type":"1 (1: Car, 2: Truck, 3: Motorcycle, 4: Bicycle 5:Pedestrian nullable,default 1)"}, }) req, _ := http.NewRequest("POST", "https://api.miliexpress.com/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.miliexpress.com/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, $serve_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) { clientBuildRoute(drivers: $drivers, route_name: $route_name, route_date: $route_date, serve_time: $serve_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) }`, variables: { "drivers": [ 1 ], "route_name": "test", "route_date": "2021-03-14", "serve_time": 3, "pickup_time": 3, "package_processing_time": 30, "package_pickup_time": 30, "order_number": 200, "balance_mode": 1, "territory_id": "1 (for multiple territory user)", "order_type": "D,P,DP,DD,P2P (D:Delivery P:Pickup,DP:Pickup Step,DD:Delivery Step,P2P:Peer to Peer)", "order_batch": "W1,W2,W3", "sorting_code": "123,234,221", "label_code": "X2,X3,X4", "warehouse_id": 12, "start_address_1": 3, "end_address_1": 2, "region_group_1": "4 (for multiple territory user)", "start_time_1": "9:00", "end_time_1": "17:00", "max_distance": 120, "vehicle_type": "1 (1: Car, 2: Truck, 3: Motorcycle, 4: Bicycle 5:Pedestrian nullable,default 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 ClientBuildRoute($drivers: [String], $route_name: String, $route_date: String, $serve_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) {\\n clientBuildRoute(drivers: $drivers, route_name: $route_name, route_date: $route_date, serve_time: $serve_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)\\n}\",\"variables\":{\"drivers\":[1],\"route_name\":\"test\",\"route_date\":\"2021-03-14\",\"serve_time\":3,\"pickup_time\":3,\"package_processing_time\":30,\"package_pickup_time\":30,\"order_number\":200,\"balance_mode\":1,\"territory_id\":\"1 (for multiple territory user)\",\"order_type\":\"D,P,DP,DD,P2P (D:Delivery P:Pickup,DP:Pickup Step,DD:Delivery Step,P2P:Peer to Peer)\",\"order_batch\":\"W1,W2,W3\",\"sorting_code\":\"123,234,221\",\"label_code\":\"X2,X3,X4\",\"warehouse_id\":12,\"start_address_1\":3,\"end_address_1\":2,\"region_group_1\":\"4 (for multiple territory user)\",\"start_time_1\":\"9:00\",\"end_time_1\":\"17:00\",\"max_distance\":120,\"vehicle_type\":\"1 (1: Car, 2: Truck, 3: Motorcycle, 4: Bicycle 5:Pedestrian nullable,default 1)\"}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.miliexpress.com/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.miliexpress.com/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, $serve_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) { clientBuildRoute(drivers: $drivers, route_name: $route_name, route_date: $route_date, serve_time: $serve_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) }', variables: {"drivers":[1],"route_name":"test","route_date":"2021-03-14","serve_time":3,"pickup_time":3,"package_processing_time":30,"package_pickup_time":30,"order_number":200,"balance_mode":1,"territory_id":"1 (for multiple territory user)","order_type":"D,P,DP,DD,P2P (D:Delivery P:Pickup,DP:Pickup Step,DD:Delivery Step,P2P:Peer to Peer)","order_batch":"W1,W2,W3","sorting_code":"123,234,221","label_code":"X2,X3,X4","warehouse_id":12,"start_address_1":3,"end_address_1":2,"region_group_1":"4 (for multiple territory user)","start_time_1":"9:00","end_time_1":"17:00","max_distance":120,"vehicle_type":"1 (1: Car, 2: Truck, 3: Motorcycle, 4: Bicycle 5:Pedestrian nullable,default 1)"} }) response = http.request(request) puts JSON.parse(response.body)

<?php require 'vendor/autoload.php'; $client = new GuzzleHttp\Client(); $response = $client->post('https://api.miliexpress.com/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, $serve_time: Int, $ppickup_time: Int, $balance_mode: Int, $package_processing_time: Int, $package_pickup_time: Int, $need_approval: Int, $territory_id: Int, $order_type: String, $order_batch: String, $sorting_code: String, $label_code: String, $warehouse_id: Int, $max_distance: Int, $vehicle_type: String) { clientBuildRoute(drivers: $drivers, route_name: $route_name, route_date: $route_date, serve_time: $serve_time, ppickup_time: $ppickup_time, balance_mode: $balance_mode, package_processing_time: $package_processing_time, package_pickup_time: $package_pickup_time, need_approval: $need_approval, territory_id: $territory_id, order_type: $order_type, order_batch: $order_batch, sorting_code: $sorting_code, label_code: $label_code, warehouse_id: $warehouse_id, max_distance: $max_distance, vehicle_type: $vehicle_type) }', 'variables' => json_decode('{"drivers":[{"id":2,"start_address":{"address_1":"2395 Madison","address_2":"Apt 4","city":"Montreal","province":"Quebec","country":"Canada","postcode":"H4B2T5","telephone":"555-5555"},"end_address":{"id":2,"address_1":"40d boul des sources","address_2":"","city":"Pointe Claire","province":"Quebec","country":"Canada","postcode":"H9S2H9","telephone":"555-6666"},"start_address_id":1,"end_address_id":2,"start_time":"09:00","end_time":"17:00","region_group_id":2001,"capacity":50,"max_distance":120,"skill_ids":[1,2]}],"route_name":"test","route_date":"2021-03-14","serve_time":3,"ppickup_time":3,"balance_mode":1,"package_processing_time":30,"package_pickup_time":30,"need_approval":"1","territory_id":"1 (for multiple territory user)","order_type":"D,P,DP,DD,P2P (D:Delivery P:Pickup,DP:Pickup Step,DD:Delivery Step,P2P:Peer to Peer)","order_batch":"W1,W2,W3","sorting_code":"607,304,021","label_code":"X2,X3,X4","warehouse_id":12,"max_distance":120,"vehicle_type":"1 (1: Car, 2: Truck, 3: Motorcycle, 4: Bicycle 5:Pedestrian nullable,default 1)"}', true), ], ]); $data = json_decode($response->getBody(), true); print_r($data);

import requests response = requests.post( 'https://api.miliexpress.com/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, $serve_time: Int, $ppickup_time: Int, $balance_mode: Int, $package_processing_time: Int, $package_pickup_time: Int, $need_approval: Int, $territory_id: Int, $order_type: String, $order_batch: String, $sorting_code: String, $label_code: String, $warehouse_id: Int, $max_distance: Int, $vehicle_type: String) { clientBuildRoute(drivers: $drivers, route_name: $route_name, route_date: $route_date, serve_time: $serve_time, ppickup_time: $ppickup_time, balance_mode: $balance_mode, package_processing_time: $package_processing_time, package_pickup_time: $package_pickup_time, need_approval: $need_approval, territory_id: $territory_id, order_type: $order_type, order_batch: $order_batch, sorting_code: $sorting_code, label_code: $label_code, warehouse_id: $warehouse_id, max_distance: $max_distance, vehicle_type: $vehicle_type) }', 'variables': {"drivers":[{"id":2,"start_address":{"address_1":"2395 Madison","address_2":"Apt 4","city":"Montreal","province":"Quebec","country":"Canada","postcode":"H4B2T5","telephone":"555-5555"},"end_address":{"id":2,"address_1":"40d boul des sources","address_2":"","city":"Pointe Claire","province":"Quebec","country":"Canada","postcode":"H9S2H9","telephone":"555-6666"},"start_address_id":1,"end_address_id":2,"start_time":"09:00","end_time":"17:00","region_group_id":2001,"capacity":50,"max_distance":120,"skill_ids":[1,2]}],"route_name":"test","route_date":"2021-03-14","serve_time":3,"ppickup_time":3,"balance_mode":1,"package_processing_time":30,"package_pickup_time":30,"need_approval":"1","territory_id":"1 (for multiple territory user)","order_type":"D,P,DP,DD,P2P (D:Delivery P:Pickup,DP:Pickup Step,DD:Delivery Step,P2P:Peer to Peer)","order_batch":"W1,W2,W3","sorting_code":"607,304,021","label_code":"X2,X3,X4","warehouse_id":12,"max_distance":120,"vehicle_type":"1 (1: Car, 2: Truck, 3: Motorcycle, 4: Bicycle 5:Pedestrian nullable,default 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 ClientBuildRoute($drivers: [String], $route_name: String, $route_date: String, $serve_time: Int, $ppickup_time: Int, $balance_mode: Int, $package_processing_time: Int, $package_pickup_time: Int, $need_approval: Int, $territory_id: Int, $order_type: String, $order_batch: String, $sorting_code: String, $label_code: String, $warehouse_id: Int, $max_distance: Int, $vehicle_type: String) { clientBuildRoute(drivers: $drivers, route_name: $route_name, route_date: $route_date, serve_time: $serve_time, ppickup_time: $ppickup_time, balance_mode: $balance_mode, package_processing_time: $package_processing_time, package_pickup_time: $package_pickup_time, need_approval: $need_approval, territory_id: $territory_id, order_type: $order_type, order_batch: $order_batch, sorting_code: $sorting_code, label_code: $label_code, warehouse_id: $warehouse_id, max_distance: $max_distance, vehicle_type: $vehicle_type) }`, "variables": {"drivers":[{"id":2,"start_address":{"address_1":"2395 Madison","address_2":"Apt 4","city":"Montreal","province":"Quebec","country":"Canada","postcode":"H4B2T5","telephone":"555-5555"},"end_address":{"id":2,"address_1":"40d boul des sources","address_2":"","city":"Pointe Claire","province":"Quebec","country":"Canada","postcode":"H9S2H9","telephone":"555-6666"},"start_address_id":1,"end_address_id":2,"start_time":"09:00","end_time":"17:00","region_group_id":2001,"capacity":50,"max_distance":120,"skill_ids":[1,2]}],"route_name":"test","route_date":"2021-03-14","serve_time":3,"ppickup_time":3,"balance_mode":1,"package_processing_time":30,"package_pickup_time":30,"need_approval":"1","territory_id":"1 (for multiple territory user)","order_type":"D,P,DP,DD,P2P (D:Delivery P:Pickup,DP:Pickup Step,DD:Delivery Step,P2P:Peer to Peer)","order_batch":"W1,W2,W3","sorting_code":"607,304,021","label_code":"X2,X3,X4","warehouse_id":12,"max_distance":120,"vehicle_type":"1 (1: Car, 2: Truck, 3: Motorcycle, 4: Bicycle 5:Pedestrian nullable,default 1)"}, }) req, _ := http.NewRequest("POST", "https://api.miliexpress.com/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.miliexpress.com/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, $serve_time: Int, $ppickup_time: Int, $balance_mode: Int, $package_processing_time: Int, $package_pickup_time: Int, $need_approval: Int, $territory_id: Int, $order_type: String, $order_batch: String, $sorting_code: String, $label_code: String, $warehouse_id: Int, $max_distance: Int, $vehicle_type: String) { clientBuildRoute(drivers: $drivers, route_name: $route_name, route_date: $route_date, serve_time: $serve_time, ppickup_time: $ppickup_time, balance_mode: $balance_mode, package_processing_time: $package_processing_time, package_pickup_time: $package_pickup_time, need_approval: $need_approval, territory_id: $territory_id, order_type: $order_type, order_batch: $order_batch, sorting_code: $sorting_code, label_code: $label_code, warehouse_id: $warehouse_id, max_distance: $max_distance, vehicle_type: $vehicle_type) }`, variables: { "drivers": [ { "id": 2, "start_address": { "address_1": "2395 Madison", "address_2": "Apt 4", "city": "Montreal", "province": "Quebec", "country": "Canada", "postcode": "H4B2T5", "telephone": "555-5555" }, "end_address": { "id": 2, "address_1": "40d boul des sources", "address_2": "", "city": "Pointe Claire", "province": "Quebec", "country": "Canada", "postcode": "H9S2H9", "telephone": "555-6666" }, "start_address_id": 1, "end_address_id": 2, "start_time": "09:00", "end_time": "17:00", "region_group_id": 2001, "capacity": 50, "max_distance": 120, "skill_ids": [ 1, 2 ] } ], "route_name": "test", "route_date": "2021-03-14", "serve_time": 3, "ppickup_time": 3, "balance_mode": 1, "package_processing_time": 30, "package_pickup_time": 30, "need_approval": "1", "territory_id": "1 (for multiple territory user)", "order_type": "D,P,DP,DD,P2P (D:Delivery P:Pickup,DP:Pickup Step,DD:Delivery Step,P2P:Peer to Peer)", "order_batch": "W1,W2,W3", "sorting_code": "607,304,021", "label_code": "X2,X3,X4", "warehouse_id": 12, "max_distance": 120, "vehicle_type": "1 (1: Car, 2: Truck, 3: Motorcycle, 4: Bicycle 5:Pedestrian nullable,default 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 ClientBuildRoute($drivers: [String], $route_name: String, $route_date: String, $serve_time: Int, $ppickup_time: Int, $balance_mode: Int, $package_processing_time: Int, $package_pickup_time: Int, $need_approval: Int, $territory_id: Int, $order_type: String, $order_batch: String, $sorting_code: String, $label_code: String, $warehouse_id: Int, $max_distance: Int, $vehicle_type: String) {\\n clientBuildRoute(drivers: $drivers, route_name: $route_name, route_date: $route_date, serve_time: $serve_time, ppickup_time: $ppickup_time, balance_mode: $balance_mode, package_processing_time: $package_processing_time, package_pickup_time: $package_pickup_time, need_approval: $need_approval, territory_id: $territory_id, order_type: $order_type, order_batch: $order_batch, sorting_code: $sorting_code, label_code: $label_code, warehouse_id: $warehouse_id, max_distance: $max_distance, vehicle_type: $vehicle_type)\\n}\",\"variables\":{\"drivers\":[{\"id\":2,\"start_address\":{\"address_1\":\"2395 Madison\",\"address_2\":\"Apt 4\",\"city\":\"Montreal\",\"province\":\"Quebec\",\"country\":\"Canada\",\"postcode\":\"H4B2T5\",\"telephone\":\"555-5555\"},\"end_address\":{\"id\":2,\"address_1\":\"40d boul des sources\",\"address_2\":\"\",\"city\":\"Pointe Claire\",\"province\":\"Quebec\",\"country\":\"Canada\",\"postcode\":\"H9S2H9\",\"telephone\":\"555-6666\"},\"start_address_id\":1,\"end_address_id\":2,\"start_time\":\"09:00\",\"end_time\":\"17:00\",\"region_group_id\":2001,\"capacity\":50,\"max_distance\":120,\"skill_ids\":[1,2]}],\"route_name\":\"test\",\"route_date\":\"2021-03-14\",\"serve_time\":3,\"ppickup_time\":3,\"balance_mode\":1,\"package_processing_time\":30,\"package_pickup_time\":30,\"need_approval\":\"1\",\"territory_id\":\"1 (for multiple territory user)\",\"order_type\":\"D,P,DP,DD,P2P (D:Delivery P:Pickup,DP:Pickup Step,DD:Delivery Step,P2P:Peer to Peer)\",\"order_batch\":\"W1,W2,W3\",\"sorting_code\":\"607,304,021\",\"label_code\":\"X2,X3,X4\",\"warehouse_id\":12,\"max_distance\":120,\"vehicle_type\":\"1 (1: Car, 2: Truck, 3: Motorcycle, 4: Bicycle 5:Pedestrian nullable,default 1)\"}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.miliexpress.com/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.miliexpress.com/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, $serve_time: Int, $ppickup_time: Int, $balance_mode: Int, $package_processing_time: Int, $package_pickup_time: Int, $need_approval: Int, $territory_id: Int, $order_type: String, $order_batch: String, $sorting_code: String, $label_code: String, $warehouse_id: Int, $max_distance: Int, $vehicle_type: String) { clientBuildRoute(drivers: $drivers, route_name: $route_name, route_date: $route_date, serve_time: $serve_time, ppickup_time: $ppickup_time, balance_mode: $balance_mode, package_processing_time: $package_processing_time, package_pickup_time: $package_pickup_time, need_approval: $need_approval, territory_id: $territory_id, order_type: $order_type, order_batch: $order_batch, sorting_code: $sorting_code, label_code: $label_code, warehouse_id: $warehouse_id, max_distance: $max_distance, vehicle_type: $vehicle_type) }', variables: {"drivers":[{"id":2,"start_address":{"address_1":"2395 Madison","address_2":"Apt 4","city":"Montreal","province":"Quebec","country":"Canada","postcode":"H4B2T5","telephone":"555-5555"},"end_address":{"id":2,"address_1":"40d boul des sources","address_2":"","city":"Pointe Claire","province":"Quebec","country":"Canada","postcode":"H9S2H9","telephone":"555-6666"},"start_address_id":1,"end_address_id":2,"start_time":"09:00","end_time":"17:00","region_group_id":2001,"capacity":50,"max_distance":120,"skill_ids":[1,2]}],"route_name":"test","route_date":"2021-03-14","serve_time":3,"ppickup_time":3,"balance_mode":1,"package_processing_time":30,"package_pickup_time":30,"need_approval":"1","territory_id":"1 (for multiple territory user)","order_type":"D,P,DP,DD,P2P (D:Delivery P:Pickup,DP:Pickup Step,DD:Delivery Step,P2P:Peer to Peer)","order_batch":"W1,W2,W3","sorting_code":"607,304,021","label_code":"X2,X3,X4","warehouse_id":12,"max_distance":120,"vehicle_type":"1 (1: Car, 2: Truck, 3: Motorcycle, 4: Bicycle 5:Pedestrian nullable,default 1)"} }) response = http.request(request) puts JSON.parse(response.body)

<?php require 'vendor/autoload.php'; $client = new GuzzleHttp\Client(); $response = $client->post('https://api.miliexpress.com/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":"365","fromDriverId":"123","toDriverId":"222"}', true), ], ]); $data = json_decode($response->getBody(), true); print_r($data);

import requests response = requests.post( 'https://api.miliexpress.com/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":"365","fromDriverId":"123","toDriverId":"222"}, }, ) 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":"365","fromDriverId":"123","toDriverId":"222"}, }) req, _ := http.NewRequest("POST", "https://api.miliexpress.com/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.miliexpress.com/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": "365", "fromDriverId": "123", "toDriverId": "222" }, }), }); 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\":\"365\",\"fromDriverId\":\"123\",\"toDriverId\":\"222\"}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.miliexpress.com/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.miliexpress.com/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":"365","fromDriverId":"123","toDriverId":"222"} }) response = http.request(request) puts JSON.parse(response.body)

<?php require 'vendor/autoload.php'; $client = new GuzzleHttp\Client(); $response = $client->post('https://api.miliexpress.com/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":123,"driver_id":456,"order_ids":[1,2,3]}', true), ], ]); $data = json_decode($response->getBody(), true); print_r($data);

import requests response = requests.post( 'https://api.miliexpress.com/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":123,"driver_id":456,"order_ids":[1,2,3]}, }, ) 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":123,"driver_id":456,"order_ids":[1,2,3]}, }) req, _ := http.NewRequest("POST", "https://api.miliexpress.com/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.miliexpress.com/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": 123, "driver_id": 456, "order_ids": [ 1, 2, 3 ] }, }), }); 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\":123,\"driver_id\":456,\"order_ids\":[1,2,3]}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.miliexpress.com/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.miliexpress.com/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":123,"driver_id":456,"order_ids":[1,2,3]} }) response = http.request(request) puts JSON.parse(response.body)

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

import requests response = requests.post( 'https://api.miliexpress.com/api/graphql', headers={ 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, json={ 'query': 'mutation ClientRoutesMoveOrder($from_route_id: Int, $order_ids: [String], $to_route_id: Int, $to_driver_id: Int) { clientRoutesMoveOrder(from_route_id: $from_route_id, order_ids: $order_ids, to_route_id: $to_route_id, to_driver_id: $to_driver_id) }', 'variables': {"from_route_id":123,"order_ids":[1,2,3],"to_route_id":456,"to_driver_id":789}, }, ) 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, $order_ids: [String], $to_route_id: Int, $to_driver_id: Int) { clientRoutesMoveOrder(from_route_id: $from_route_id, order_ids: $order_ids, to_route_id: $to_route_id, to_driver_id: $to_driver_id) }`, "variables": {"from_route_id":123,"order_ids":[1,2,3],"to_route_id":456,"to_driver_id":789}, }) req, _ := http.NewRequest("POST", "https://api.miliexpress.com/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.miliexpress.com/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, $order_ids: [String], $to_route_id: Int, $to_driver_id: Int) { clientRoutesMoveOrder(from_route_id: $from_route_id, order_ids: $order_ids, to_route_id: $to_route_id, to_driver_id: $to_driver_id) }`, variables: { "from_route_id": 123, "order_ids": [ 1, 2, 3 ], "to_route_id": 456, "to_driver_id": 789 }, }), }); 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, $order_ids: [String], $to_route_id: Int, $to_driver_id: Int) {\\n clientRoutesMoveOrder(from_route_id: $from_route_id, order_ids: $order_ids, to_route_id: $to_route_id, to_driver_id: $to_driver_id)\\n}\",\"variables\":{\"from_route_id\":123,\"order_ids\":[1,2,3],\"to_route_id\":456,\"to_driver_id\":789}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.miliexpress.com/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.miliexpress.com/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, $order_ids: [String], $to_route_id: Int, $to_driver_id: Int) { clientRoutesMoveOrder(from_route_id: $from_route_id, order_ids: $order_ids, to_route_id: $to_route_id, to_driver_id: $to_driver_id) }', variables: {"from_route_id":123,"order_ids":[1,2,3],"to_route_id":456,"to_driver_id":789} }) response = http.request(request) puts JSON.parse(response.body)

<?php require 'vendor/autoload.php'; $client = new GuzzleHttp\Client(); $response = $client->post('https://api.miliexpress.com/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":123,"order_ids":[1,2,3],"cancel_order":0}', true), ], ]); $data = json_decode($response->getBody(), true); print_r($data);

import requests response = requests.post( 'https://api.miliexpress.com/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":123,"order_ids":[1,2,3],"cancel_order":0}, }, ) 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":123,"order_ids":[1,2,3],"cancel_order":0}, }) req, _ := http.NewRequest("POST", "https://api.miliexpress.com/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.miliexpress.com/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": 123, "order_ids": [ 1, 2, 3 ], "cancel_order": 0 }, }), }); 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\":123,\"order_ids\":[1,2,3],\"cancel_order\":0}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.miliexpress.com/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.miliexpress.com/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":123,"order_ids":[1,2,3],"cancel_order":0} }) response = http.request(request) puts JSON.parse(response.body)

<?php require 'vendor/autoload.php'; $client = new GuzzleHttp\Client(); $response = $client->post('https://api.miliexpress.com/api/graphql', [ 'headers' => [ 'Content-Type' => 'application/json', 'Accept' => 'application/json', 'Authorization' => 'Bearer YOUR_TOKEN', ], 'json' => [ 'query' => 'mutation ClientRoutesOptimize($async: Boolean, $routeId: Int, $driverIds: [Int], $driverAddresses: String) { clientRoutesOptimize(async: $async, routeId: $routeId, driverIds: $driverIds, driverAddresses: $driverAddresses) }', 'variables' => json_decode('{"async":true,"routeId":123,"driverIds":[11,22,33],"driverAddresses":{"11":{"start_address_id":1001,"start_address":{"name":"Warehouse A","lat":43.65107,"lng":-79.347015},"end_address":{"name":"Dropoff Point Z","address_1":"456 King St","city":"Toronto","province":"ON","country":"CA","postcode":"M5V1K1"}}}}', true), ], ]); $data = json_decode($response->getBody(), true); print_r($data);

import requests response = requests.post( 'https://api.miliexpress.com/api/graphql', headers={ 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, json={ 'query': 'mutation ClientRoutesOptimize($async: Boolean, $routeId: Int, $driverIds: [Int], $driverAddresses: String) { clientRoutesOptimize(async: $async, routeId: $routeId, driverIds: $driverIds, driverAddresses: $driverAddresses) }', 'variables': {"async":true,"routeId":123,"driverIds":[11,22,33],"driverAddresses":{"11":{"start_address_id":1001,"start_address":{"name":"Warehouse A","lat":43.65107,"lng":-79.347015},"end_address":{"name":"Dropoff Point Z","address_1":"456 King St","city":"Toronto","province":"ON","country":"CA","postcode":"M5V1K1"}}}}, }, ) 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($async: Boolean, $routeId: Int, $driverIds: [Int], $driverAddresses: String) { clientRoutesOptimize(async: $async, routeId: $routeId, driverIds: $driverIds, driverAddresses: $driverAddresses) }`, "variables": {"async":true,"routeId":123,"driverIds":[11,22,33],"driverAddresses":{"11":{"start_address_id":1001,"start_address":{"name":"Warehouse A","lat":43.65107,"lng":-79.347015},"end_address":{"name":"Dropoff Point Z","address_1":"456 King St","city":"Toronto","province":"ON","country":"CA","postcode":"M5V1K1"}}}}, }) req, _ := http.NewRequest("POST", "https://api.miliexpress.com/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.miliexpress.com/api/graphql', { method: 'POST', headers: { 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, body: JSON.stringify({ query: `mutation ClientRoutesOptimize($async: Boolean, $routeId: Int, $driverIds: [Int], $driverAddresses: String) { clientRoutesOptimize(async: $async, routeId: $routeId, driverIds: $driverIds, driverAddresses: $driverAddresses) }`, variables: { "async": true, "routeId": 123, "driverIds": [ 11, 22, 33 ], "driverAddresses": { "11": { "start_address_id": 1001, "start_address": { "name": "Warehouse A", "lat": 43.65107, "lng": -79.347015 }, "end_address": { "name": "Dropoff Point Z", "address_1": "456 King St", "city": "Toronto", "province": "ON", "country": "CA", "postcode": "M5V1K1" } } } }, }), }); 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($async: Boolean, $routeId: Int, $driverIds: [Int], $driverAddresses: String) {\\n clientRoutesOptimize(async: $async, routeId: $routeId, driverIds: $driverIds, driverAddresses: $driverAddresses)\\n}\",\"variables\":{\"async\":true,\"routeId\":123,\"driverIds\":[11,22,33],\"driverAddresses\":{\"11\":{\"start_address_id\":1001,\"start_address\":{\"name\":\"Warehouse A\",\"lat\":43.65107,\"lng\":-79.347015},\"end_address\":{\"name\":\"Dropoff Point Z\",\"address_1\":\"456 King St\",\"city\":\"Toronto\",\"province\":\"ON\",\"country\":\"CA\",\"postcode\":\"M5V1K1\"}}}}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.miliexpress.com/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.miliexpress.com/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($async: Boolean, $routeId: Int, $driverIds: [Int], $driverAddresses: String) { clientRoutesOptimize(async: $async, routeId: $routeId, driverIds: $driverIds, driverAddresses: $driverAddresses) }', variables: {"async":true,"routeId":123,"driverIds":[11,22,33],"driverAddresses":{"11":{"start_address_id":1001,"start_address":{"name":"Warehouse A","lat":43.65107,"lng":-79.347015},"end_address":{"name":"Dropoff Point Z","address_1":"456 King St","city":"Toronto","province":"ON","country":"CA","postcode":"M5V1K1"}}}} }) response = http.request(request) puts JSON.parse(response.body)

<?php require 'vendor/autoload.php'; $client = new GuzzleHttp\Client(); $response = $client->post('https://api.miliexpress.com/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":123}', true), ], ]); $data = json_decode($response->getBody(), true); print_r($data);

import requests response = requests.post( 'https://api.miliexpress.com/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":123}, }, ) 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":123}, }) req, _ := http.NewRequest("POST", "https://api.miliexpress.com/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.miliexpress.com/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": 123 }, }), }); 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\":123}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.miliexpress.com/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.miliexpress.com/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":123} }) response = http.request(request) puts JSON.parse(response.body)

<?php require 'vendor/autoload.php'; $client = new GuzzleHttp\Client(); $response = $client->post('https://api.miliexpress.com/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.miliexpress.com/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.miliexpress.com/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.miliexpress.com/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.miliexpress.com/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.miliexpress.com/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.miliexpress.com/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.miliexpress.com/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.miliexpress.com/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.miliexpress.com/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.miliexpress.com/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.miliexpress.com/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.miliexpress.com/api/graphql', [ 'headers' => [ 'Content-Type' => 'application/json', 'Accept' => 'application/json', 'Authorization' => 'Bearer YOUR_TOKEN', ], 'json' => [ 'query' => 'mutation ShippingGetStopNumber($route_id: String, $type: String, $sub_route_count: Int) { shippingGetStopNumber(route_id: $route_id, type: $type, sub_route_count: $sub_route_count) }', 'variables' => json_decode('{"route_id":"365","type":"ref","sub_route_count":1}', true), ], ]); $data = json_decode($response->getBody(), true); print_r($data);

import requests response = requests.post( 'https://api.miliexpress.com/api/graphql', headers={ 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, json={ 'query': 'mutation ShippingGetStopNumber($route_id: String, $type: String, $sub_route_count: Int) { shippingGetStopNumber(route_id: $route_id, type: $type, sub_route_count: $sub_route_count) }', 'variables': {"route_id":"365","type":"ref","sub_route_count":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 ShippingGetStopNumber($route_id: String, $type: String, $sub_route_count: Int) { shippingGetStopNumber(route_id: $route_id, type: $type, sub_route_count: $sub_route_count) }`, "variables": {"route_id":"365","type":"ref","sub_route_count":1}, }) req, _ := http.NewRequest("POST", "https://api.miliexpress.com/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.miliexpress.com/api/graphql', { method: 'POST', headers: { 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, body: JSON.stringify({ query: `mutation ShippingGetStopNumber($route_id: String, $type: String, $sub_route_count: Int) { shippingGetStopNumber(route_id: $route_id, type: $type, sub_route_count: $sub_route_count) }`, variables: { "route_id": "365", "type": "ref", "sub_route_count": 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 ShippingGetStopNumber($route_id: String, $type: String, $sub_route_count: Int) {\\n shippingGetStopNumber(route_id: $route_id, type: $type, sub_route_count: $sub_route_count)\\n}\",\"variables\":{\"route_id\":\"365\",\"type\":\"ref\",\"sub_route_count\":1}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.miliexpress.com/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.miliexpress.com/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 ShippingGetStopNumber($route_id: String, $type: String, $sub_route_count: Int) { shippingGetStopNumber(route_id: $route_id, type: $type, sub_route_count: $sub_route_count) }', variables: {"route_id":"365","type":"ref","sub_route_count":1} }) response = http.request(request) puts JSON.parse(response.body)

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

import requests response = requests.post( 'https://api.miliexpress.com/api/graphql', headers={ 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, json={ 'query': 'mutation ShippingGetShippingLabel($id: String, $type: String, $packages: Int) { shippingGetShippingLabel(id: $id, type: $type, packages: $packages) }', 'variables': {"id":"17341","type":"TRACKING_NUMBER","packages":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 ShippingGetShippingLabel($id: String, $type: String, $packages: Int) { shippingGetShippingLabel(id: $id, type: $type, packages: $packages) }`, "variables": {"id":"17341","type":"TRACKING_NUMBER","packages":1}, }) req, _ := http.NewRequest("POST", "https://api.miliexpress.com/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.miliexpress.com/api/graphql', { method: 'POST', headers: { 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, body: JSON.stringify({ query: `mutation ShippingGetShippingLabel($id: String, $type: String, $packages: Int) { shippingGetShippingLabel(id: $id, type: $type, packages: $packages) }`, variables: { "id": "17341", "type": "TRACKING_NUMBER", "packages": 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 ShippingGetShippingLabel($id: String, $type: String, $packages: Int) {\\n shippingGetShippingLabel(id: $id, type: $type, packages: $packages)\\n}\",\"variables\":{\"id\":\"17341\",\"type\":\"TRACKING_NUMBER\",\"packages\":1}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.miliexpress.com/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.miliexpress.com/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 ShippingGetShippingLabel($id: String, $type: String, $packages: Int) { shippingGetShippingLabel(id: $id, type: $type, packages: $packages) }', variables: {"id":"17341","type":"TRACKING_NUMBER","packages":1} }) response = http.request(request) puts JSON.parse(response.body)

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

import requests response = requests.post( 'https://api.miliexpress.com/api/graphql', headers={ 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, json={ 'query': 'mutation ShippingGetShippingLabel($id: String, $type: String, $packages: Int) { shippingGetShippingLabel(id: $id, type: $type, packages: $packages) }', 'variables': {"id":"17341","type":"TRACKING_NUMBER","packages":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 ShippingGetShippingLabel($id: String, $type: String, $packages: Int) { shippingGetShippingLabel(id: $id, type: $type, packages: $packages) }`, "variables": {"id":"17341","type":"TRACKING_NUMBER","packages":1}, }) req, _ := http.NewRequest("POST", "https://api.miliexpress.com/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.miliexpress.com/api/graphql', { method: 'POST', headers: { 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, body: JSON.stringify({ query: `mutation ShippingGetShippingLabel($id: String, $type: String, $packages: Int) { shippingGetShippingLabel(id: $id, type: $type, packages: $packages) }`, variables: { "id": "17341", "type": "TRACKING_NUMBER", "packages": 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 ShippingGetShippingLabel($id: String, $type: String, $packages: Int) {\\n shippingGetShippingLabel(id: $id, type: $type, packages: $packages)\\n}\",\"variables\":{\"id\":\"17341\",\"type\":\"TRACKING_NUMBER\",\"packages\":1}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.miliexpress.com/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.miliexpress.com/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 ShippingGetShippingLabel($id: String, $type: String, $packages: Int) { shippingGetShippingLabel(id: $id, type: $type, packages: $packages) }', variables: {"id":"17341","type":"TRACKING_NUMBER","packages":1} }) response = http.request(request) puts JSON.parse(response.body)

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

import requests response = requests.post( 'https://api.miliexpress.com/api/graphql', headers={ 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, json={ 'query': 'mutation Addressbook { addressbook }', '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 Addressbook { addressbook }`, "variables": map[string]interface{}{}, }) req, _ := http.NewRequest("POST", "https://api.miliexpress.com/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.miliexpress.com/api/graphql', { method: 'POST', headers: { 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, body: JSON.stringify({ query: `mutation Addressbook { addressbook }`, 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 Addressbook {\\n addressbook\\n}\",\"variables\":{}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.miliexpress.com/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.miliexpress.com/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 Addressbook { addressbook }', variables: {} }) response = http.request(request) puts JSON.parse(response.body)

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

import requests response = requests.post( 'https://api.miliexpress.com/api/graphql', headers={ 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, json={ 'query': 'mutation Addressbook($address_id: Int) { addressbook(address_id: $address_id) }', 'variables': {"address_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 Addressbook($address_id: Int) { addressbook(address_id: $address_id) }`, "variables": {"address_id":1}, }) req, _ := http.NewRequest("POST", "https://api.miliexpress.com/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.miliexpress.com/api/graphql', { method: 'POST', headers: { 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, body: JSON.stringify({ query: `mutation Addressbook($address_id: Int) { addressbook(address_id: $address_id) }`, variables: { "address_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 Addressbook($address_id: Int) {\\n addressbook(address_id: $address_id)\\n}\",\"variables\":{\"address_id\":1}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.miliexpress.com/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.miliexpress.com/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 Addressbook($address_id: Int) { addressbook(address_id: $address_id) }', variables: {"address_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.miliexpress.com/api/graphql', [ 'headers' => [ 'Content-Type' => 'application/json', 'Accept' => 'application/json', 'Authorization' => 'Bearer YOUR_TOKEN', ], 'json' => [ 'query' => 'mutation Addressbook($address_id: Int) { addressbook(address_id: $address_id) }', 'variables' => json_decode('{"address_id":1}', true), ], ]); $data = json_decode($response->getBody(), true); print_r($data);

import requests response = requests.post( 'https://api.miliexpress.com/api/graphql', headers={ 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, json={ 'query': 'mutation Addressbook($address_id: Int) { addressbook(address_id: $address_id) }', 'variables': {"address_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 Addressbook($address_id: Int) { addressbook(address_id: $address_id) }`, "variables": {"address_id":1}, }) req, _ := http.NewRequest("POST", "https://api.miliexpress.com/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.miliexpress.com/api/graphql', { method: 'POST', headers: { 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, body: JSON.stringify({ query: `mutation Addressbook($address_id: Int) { addressbook(address_id: $address_id) }`, variables: { "address_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 Addressbook($address_id: Int) {\\n addressbook(address_id: $address_id)\\n}\",\"variables\":{\"address_id\":1}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.miliexpress.com/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.miliexpress.com/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 Addressbook($address_id: Int) { addressbook(address_id: $address_id) }', variables: {"address_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.miliexpress.com/api/graphql', [ 'headers' => [ 'Content-Type' => 'application/json', 'Accept' => 'application/json', 'Authorization' => 'Bearer YOUR_TOKEN', ], 'json' => [ 'query' => 'mutation Driverinfo { driverinfo }', 'variables' => [], ], ]); $data = json_decode($response->getBody(), true); print_r($data);

import requests response = requests.post( 'https://api.miliexpress.com/api/graphql', headers={ 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, json={ 'query': 'mutation Driverinfo { driverinfo }', '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 Driverinfo { driverinfo }`, "variables": map[string]interface{}{}, }) req, _ := http.NewRequest("POST", "https://api.miliexpress.com/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.miliexpress.com/api/graphql', { method: 'POST', headers: { 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, body: JSON.stringify({ query: `mutation Driverinfo { driverinfo }`, 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 Driverinfo {\\n driverinfo\\n}\",\"variables\":{}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.miliexpress.com/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.miliexpress.com/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 { driverinfo }', variables: {} }) response = http.request(request) puts JSON.parse(response.body)

<?php require 'vendor/autoload.php'; $client = new GuzzleHttp\Client(); $response = $client->post('https://api.miliexpress.com/api/graphql', [ 'headers' => [ 'Content-Type' => 'application/json', 'Accept' => 'application/json', 'Authorization' => 'Bearer YOUR_TOKEN', ], 'json' => [ 'query' => 'mutation Driverinfo($driver_id: Int) { driverinfo(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.miliexpress.com/api/graphql', headers={ 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, json={ 'query': 'mutation Driverinfo($driver_id: Int) { driverinfo(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 Driverinfo($driver_id: Int) { driverinfo(driver_id: $driver_id) }`, "variables": {"driver_id":1}, }) req, _ := http.NewRequest("POST", "https://api.miliexpress.com/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.miliexpress.com/api/graphql', { method: 'POST', headers: { 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, body: JSON.stringify({ query: `mutation Driverinfo($driver_id: Int) { driverinfo(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 Driverinfo($driver_id: Int) {\\n driverinfo(driver_id: $driver_id)\\n}\",\"variables\":{\"driver_id\":1}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.miliexpress.com/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.miliexpress.com/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($driver_id: Int) { driverinfo(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.miliexpress.com/api/graphql', [ 'headers' => [ 'Content-Type' => 'application/json', 'Accept' => 'application/json', 'Authorization' => 'Bearer YOUR_TOKEN', ], 'json' => [ 'query' => 'mutation Driverinfo($driver_id: Int) { driverinfo(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.miliexpress.com/api/graphql', headers={ 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, json={ 'query': 'mutation Driverinfo($driver_id: Int) { driverinfo(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 Driverinfo($driver_id: Int) { driverinfo(driver_id: $driver_id) }`, "variables": {"driver_id":1}, }) req, _ := http.NewRequest("POST", "https://api.miliexpress.com/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.miliexpress.com/api/graphql', { method: 'POST', headers: { 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, body: JSON.stringify({ query: `mutation Driverinfo($driver_id: Int) { driverinfo(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 Driverinfo($driver_id: Int) {\\n driverinfo(driver_id: $driver_id)\\n}\",\"variables\":{\"driver_id\":1}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.miliexpress.com/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.miliexpress.com/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($driver_id: Int) { driverinfo(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.miliexpress.com/api/graphql', [ 'headers' => [ 'Content-Type' => 'application/json', 'Accept' => 'application/json', 'Authorization' => 'Bearer YOUR_TOKEN', ], 'json' => [ 'query' => 'mutation Skills { skills }', 'variables' => [], ], ]); $data = json_decode($response->getBody(), true); print_r($data);

import requests response = requests.post( 'https://api.miliexpress.com/api/graphql', headers={ 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, json={ 'query': 'mutation Skills { skills }', '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 Skills { skills }`, "variables": map[string]interface{}{}, }) req, _ := http.NewRequest("POST", "https://api.miliexpress.com/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.miliexpress.com/api/graphql', { method: 'POST', headers: { 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, body: JSON.stringify({ query: `mutation Skills { skills }`, 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 Skills {\\n skills\\n}\",\"variables\":{}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.miliexpress.com/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.miliexpress.com/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 Skills { skills }', variables: {} }) response = http.request(request) puts JSON.parse(response.body)

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

import requests response = requests.post( 'https://api.miliexpress.com/api/graphql', headers={ 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, json={ 'query': 'mutation Skills($skill_id: Int) { skills(skill_id: $skill_id) }', 'variables': {"skill_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 Skills($skill_id: Int) { skills(skill_id: $skill_id) }`, "variables": {"skill_id":1}, }) req, _ := http.NewRequest("POST", "https://api.miliexpress.com/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.miliexpress.com/api/graphql', { method: 'POST', headers: { 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, body: JSON.stringify({ query: `mutation Skills($skill_id: Int) { skills(skill_id: $skill_id) }`, variables: { "skill_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 Skills($skill_id: Int) {\\n skills(skill_id: $skill_id)\\n}\",\"variables\":{\"skill_id\":1}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.miliexpress.com/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.miliexpress.com/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 Skills($skill_id: Int) { skills(skill_id: $skill_id) }', variables: {"skill_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.miliexpress.com/api/graphql', [ 'headers' => [ 'Content-Type' => 'application/json', 'Accept' => 'application/json', 'Authorization' => 'Bearer YOUR_TOKEN', ], 'json' => [ 'query' => 'mutation Skills($skill_id: Int) { skills(skill_id: $skill_id) }', 'variables' => json_decode('{"skill_id":1}', true), ], ]); $data = json_decode($response->getBody(), true); print_r($data);

import requests response = requests.post( 'https://api.miliexpress.com/api/graphql', headers={ 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, json={ 'query': 'mutation Skills($skill_id: Int) { skills(skill_id: $skill_id) }', 'variables': {"skill_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 Skills($skill_id: Int) { skills(skill_id: $skill_id) }`, "variables": {"skill_id":1}, }) req, _ := http.NewRequest("POST", "https://api.miliexpress.com/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.miliexpress.com/api/graphql', { method: 'POST', headers: { 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, body: JSON.stringify({ query: `mutation Skills($skill_id: Int) { skills(skill_id: $skill_id) }`, variables: { "skill_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 Skills($skill_id: Int) {\\n skills(skill_id: $skill_id)\\n}\",\"variables\":{\"skill_id\":1}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.miliexpress.com/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.miliexpress.com/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 Skills($skill_id: Int) { skills(skill_id: $skill_id) }', variables: {"skill_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.miliexpress.com/api/graphql', [ 'headers' => [ 'Content-Type' => 'application/json', 'Accept' => 'application/json', 'Authorization' => 'Bearer YOUR_TOKEN', ], 'json' => [ 'query' => 'mutation Returnreasons { returnreasons }', 'variables' => [], ], ]); $data = json_decode($response->getBody(), true); print_r($data);

import requests response = requests.post( 'https://api.miliexpress.com/api/graphql', headers={ 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, json={ 'query': 'mutation Returnreasons { returnreasons }', '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 Returnreasons { returnreasons }`, "variables": map[string]interface{}{}, }) req, _ := http.NewRequest("POST", "https://api.miliexpress.com/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.miliexpress.com/api/graphql', { method: 'POST', headers: { 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, body: JSON.stringify({ query: `mutation Returnreasons { returnreasons }`, 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 Returnreasons {\\n returnreasons\\n}\",\"variables\":{}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.miliexpress.com/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.miliexpress.com/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 Returnreasons { returnreasons }', variables: {} }) response = http.request(request) puts JSON.parse(response.body)

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

import requests response = requests.post( 'https://api.miliexpress.com/api/graphql', headers={ 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, json={ 'query': 'mutation Returnreasons($rr_id: Int) { returnreasons(rr_id: $rr_id) }', 'variables': {"rr_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 Returnreasons($rr_id: Int) { returnreasons(rr_id: $rr_id) }`, "variables": {"rr_id":1}, }) req, _ := http.NewRequest("POST", "https://api.miliexpress.com/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.miliexpress.com/api/graphql', { method: 'POST', headers: { 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, body: JSON.stringify({ query: `mutation Returnreasons($rr_id: Int) { returnreasons(rr_id: $rr_id) }`, variables: { "rr_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 Returnreasons($rr_id: Int) {\\n returnreasons(rr_id: $rr_id)\\n}\",\"variables\":{\"rr_id\":1}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.miliexpress.com/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.miliexpress.com/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 Returnreasons($rr_id: Int) { returnreasons(rr_id: $rr_id) }', variables: {"rr_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.miliexpress.com/api/graphql', [ 'headers' => [ 'Content-Type' => 'application/json', 'Accept' => 'application/json', 'Authorization' => 'Bearer YOUR_TOKEN', ], 'json' => [ 'query' => 'mutation Returnreasons($rr_id: Int) { returnreasons(rr_id: $rr_id) }', 'variables' => json_decode('{"rr_id":1}', true), ], ]); $data = json_decode($response->getBody(), true); print_r($data);

import requests response = requests.post( 'https://api.miliexpress.com/api/graphql', headers={ 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, json={ 'query': 'mutation Returnreasons($rr_id: Int) { returnreasons(rr_id: $rr_id) }', 'variables': {"rr_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 Returnreasons($rr_id: Int) { returnreasons(rr_id: $rr_id) }`, "variables": {"rr_id":1}, }) req, _ := http.NewRequest("POST", "https://api.miliexpress.com/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.miliexpress.com/api/graphql', { method: 'POST', headers: { 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, body: JSON.stringify({ query: `mutation Returnreasons($rr_id: Int) { returnreasons(rr_id: $rr_id) }`, variables: { "rr_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 Returnreasons($rr_id: Int) {\\n returnreasons(rr_id: $rr_id)\\n}\",\"variables\":{\"rr_id\":1}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.miliexpress.com/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.miliexpress.com/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 Returnreasons($rr_id: Int) { returnreasons(rr_id: $rr_id) }', variables: {"rr_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.miliexpress.com/api/graphql', [ 'headers' => [ 'Content-Type' => 'application/json', 'Accept' => 'application/json', 'Authorization' => 'Bearer YOUR_TOKEN', ], 'json' => [ 'query' => 'mutation LabelserviceRate($postcode: String, $street_number: String, $street_name: String, $apt: String, $buzz_code: String, $ref: String, $city: String, $province: String, $country: String, $name: String, $email: String, $telephone: String, $note: String, $notification_language: String, $need_pick_up: Int) { labelserviceRate(postcode: $postcode, street_number: $street_number, street_name: $street_name, apt: $apt, buzz_code: $buzz_code, ref: $ref, city: $city, province: $province, country: $country, name: $name, email: $email, telephone: $telephone, note: $note, notification_language: $notification_language, need_pick_up: $need_pick_up) }', 'variables' => json_decode('{"postcode":"H9S2H9","street_number":"2667","street_name":"boul des sources","apt":"123","buzz_code":"9393","ref":"altima-4","city":"pointe-claire","province":"QC","country":"Canada","name":"John","email":"join@gmail.com","telephone":"5555555555","note":"customer note","notification_language":"en","need_pick_up":"0 (no) or 1 (need pickup) or 2 (Inbound scan required) or 3 (need batch pickup)"}', true), ], ]); $data = json_decode($response->getBody(), true); print_r($data);

import requests response = requests.post( 'https://api.miliexpress.com/api/graphql', headers={ 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, json={ 'query': 'mutation LabelserviceRate($postcode: String, $street_number: String, $street_name: String, $apt: String, $buzz_code: String, $ref: String, $city: String, $province: String, $country: String, $name: String, $email: String, $telephone: String, $note: String, $notification_language: String, $need_pick_up: Int) { labelserviceRate(postcode: $postcode, street_number: $street_number, street_name: $street_name, apt: $apt, buzz_code: $buzz_code, ref: $ref, city: $city, province: $province, country: $country, name: $name, email: $email, telephone: $telephone, note: $note, notification_language: $notification_language, need_pick_up: $need_pick_up) }', 'variables': {"postcode":"H9S2H9","street_number":"2667","street_name":"boul des sources","apt":"123","buzz_code":"9393","ref":"altima-4","city":"pointe-claire","province":"QC","country":"Canada","name":"John","email":"join@gmail.com","telephone":"5555555555","note":"customer note","notification_language":"en","need_pick_up":"0 (no) or 1 (need pickup) or 2 (Inbound scan required) or 3 (need batch pickup)"}, }, ) 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 LabelserviceRate($postcode: String, $street_number: String, $street_name: String, $apt: String, $buzz_code: String, $ref: String, $city: String, $province: String, $country: String, $name: String, $email: String, $telephone: String, $note: String, $notification_language: String, $need_pick_up: Int) { labelserviceRate(postcode: $postcode, street_number: $street_number, street_name: $street_name, apt: $apt, buzz_code: $buzz_code, ref: $ref, city: $city, province: $province, country: $country, name: $name, email: $email, telephone: $telephone, note: $note, notification_language: $notification_language, need_pick_up: $need_pick_up) }`, "variables": {"postcode":"H9S2H9","street_number":"2667","street_name":"boul des sources","apt":"123","buzz_code":"9393","ref":"altima-4","city":"pointe-claire","province":"QC","country":"Canada","name":"John","email":"join@gmail.com","telephone":"5555555555","note":"customer note","notification_language":"en","need_pick_up":"0 (no) or 1 (need pickup) or 2 (Inbound scan required) or 3 (need batch pickup)"}, }) req, _ := http.NewRequest("POST", "https://api.miliexpress.com/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.miliexpress.com/api/graphql', { method: 'POST', headers: { 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, body: JSON.stringify({ query: `mutation LabelserviceRate($postcode: String, $street_number: String, $street_name: String, $apt: String, $buzz_code: String, $ref: String, $city: String, $province: String, $country: String, $name: String, $email: String, $telephone: String, $note: String, $notification_language: String, $need_pick_up: Int) { labelserviceRate(postcode: $postcode, street_number: $street_number, street_name: $street_name, apt: $apt, buzz_code: $buzz_code, ref: $ref, city: $city, province: $province, country: $country, name: $name, email: $email, telephone: $telephone, note: $note, notification_language: $notification_language, need_pick_up: $need_pick_up) }`, variables: { "postcode": "H9S2H9", "street_number": "2667", "street_name": "boul des sources", "apt": "123", "buzz_code": "9393", "ref": "altima-4", "city": "pointe-claire", "province": "QC", "country": "Canada", "name": "John", "email": "join@gmail.com", "telephone": "5555555555", "note": "customer note", "notification_language": "en", "need_pick_up": "0 (no) or 1 (need pickup) or 2 (Inbound scan required) or 3 (need batch pickup)" }, }), }); const data = await response.json(); console.log(data);

import java.net.http.*; import java.net.URI; HttpClient client = HttpClient.newHttpClient(); String body = "{\"query\":\"mutation LabelserviceRate($postcode: String, $street_number: String, $street_name: String, $apt: String, $buzz_code: String, $ref: String, $city: String, $province: String, $country: String, $name: String, $email: String, $telephone: String, $note: String, $notification_language: String, $need_pick_up: Int) {\\n labelserviceRate(postcode: $postcode, street_number: $street_number, street_name: $street_name, apt: $apt, buzz_code: $buzz_code, ref: $ref, city: $city, province: $province, country: $country, name: $name, email: $email, telephone: $telephone, note: $note, notification_language: $notification_language, need_pick_up: $need_pick_up)\\n}\",\"variables\":{\"postcode\":\"H9S2H9\",\"street_number\":\"2667\",\"street_name\":\"boul des sources\",\"apt\":\"123\",\"buzz_code\":\"9393\",\"ref\":\"altima-4\",\"city\":\"pointe-claire\",\"province\":\"QC\",\"country\":\"Canada\",\"name\":\"John\",\"email\":\"join@gmail.com\",\"telephone\":\"5555555555\",\"note\":\"customer note\",\"notification_language\":\"en\",\"need_pick_up\":\"0 (no) or 1 (need pickup) or 2 (Inbound scan required) or 3 (need batch pickup)\"}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.miliexpress.com/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.miliexpress.com/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 LabelserviceRate($postcode: String, $street_number: String, $street_name: String, $apt: String, $buzz_code: String, $ref: String, $city: String, $province: String, $country: String, $name: String, $email: String, $telephone: String, $note: String, $notification_language: String, $need_pick_up: Int) { labelserviceRate(postcode: $postcode, street_number: $street_number, street_name: $street_name, apt: $apt, buzz_code: $buzz_code, ref: $ref, city: $city, province: $province, country: $country, name: $name, email: $email, telephone: $telephone, note: $note, notification_language: $notification_language, need_pick_up: $need_pick_up) }', variables: {"postcode":"H9S2H9","street_number":"2667","street_name":"boul des sources","apt":"123","buzz_code":"9393","ref":"altima-4","city":"pointe-claire","province":"QC","country":"Canada","name":"John","email":"join@gmail.com","telephone":"5555555555","note":"customer note","notification_language":"en","need_pick_up":"0 (no) or 1 (need pickup) or 2 (Inbound scan required) or 3 (need batch pickup)"} }) response = http.request(request) puts JSON.parse(response.body)

<?php require 'vendor/autoload.php'; $client = new GuzzleHttp\Client(); $response = $client->post('https://api.miliexpress.com/api/graphql', [ 'headers' => [ 'Content-Type' => 'application/json', 'Accept' => 'application/json', 'Authorization' => 'Bearer YOUR_TOKEN', ], 'json' => [ 'query' => 'mutation LabelserviceSubmitOrder($postcode: String, $street_number: String, $street_name: String, $apt: String, $buzz_code: String, $ref: String, $order_code: String, $city: String, $province: String, $country: String, $name: String, $email: String, $telephone: String, $note: String, $notification_language: String, $need_pick_up: Int) { labelserviceSubmitOrder(postcode: $postcode, street_number: $street_number, street_name: $street_name, apt: $apt, buzz_code: $buzz_code, ref: $ref, order_code: $order_code, city: $city, province: $province, country: $country, name: $name, email: $email, telephone: $telephone, note: $note, notification_language: $notification_language, need_pick_up: $need_pick_up) }', 'variables' => json_decode('{"postcode":"H9S2H9","street_number":"2667","street_name":"boul des sources","apt":"123","buzz_code":"9393","ref":"altima-4","order_code":"ABC12","city":"pointe-claire","province":"QC","country":"Canada","name":"John","email":"join@gmail.com","telephone":"5555555555","note":"customer note","notification_language":"en","need_pick_up":"0 (no) or 1 (need pickup) or 2 (Inbound scan required) or 3 (need batch pickup)"}', true), ], ]); $data = json_decode($response->getBody(), true); print_r($data);

import requests response = requests.post( 'https://api.miliexpress.com/api/graphql', headers={ 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, json={ 'query': 'mutation LabelserviceSubmitOrder($postcode: String, $street_number: String, $street_name: String, $apt: String, $buzz_code: String, $ref: String, $order_code: String, $city: String, $province: String, $country: String, $name: String, $email: String, $telephone: String, $note: String, $notification_language: String, $need_pick_up: Int) { labelserviceSubmitOrder(postcode: $postcode, street_number: $street_number, street_name: $street_name, apt: $apt, buzz_code: $buzz_code, ref: $ref, order_code: $order_code, city: $city, province: $province, country: $country, name: $name, email: $email, telephone: $telephone, note: $note, notification_language: $notification_language, need_pick_up: $need_pick_up) }', 'variables': {"postcode":"H9S2H9","street_number":"2667","street_name":"boul des sources","apt":"123","buzz_code":"9393","ref":"altima-4","order_code":"ABC12","city":"pointe-claire","province":"QC","country":"Canada","name":"John","email":"join@gmail.com","telephone":"5555555555","note":"customer note","notification_language":"en","need_pick_up":"0 (no) or 1 (need pickup) or 2 (Inbound scan required) or 3 (need batch pickup)"}, }, ) 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 LabelserviceSubmitOrder($postcode: String, $street_number: String, $street_name: String, $apt: String, $buzz_code: String, $ref: String, $order_code: String, $city: String, $province: String, $country: String, $name: String, $email: String, $telephone: String, $note: String, $notification_language: String, $need_pick_up: Int) { labelserviceSubmitOrder(postcode: $postcode, street_number: $street_number, street_name: $street_name, apt: $apt, buzz_code: $buzz_code, ref: $ref, order_code: $order_code, city: $city, province: $province, country: $country, name: $name, email: $email, telephone: $telephone, note: $note, notification_language: $notification_language, need_pick_up: $need_pick_up) }`, "variables": {"postcode":"H9S2H9","street_number":"2667","street_name":"boul des sources","apt":"123","buzz_code":"9393","ref":"altima-4","order_code":"ABC12","city":"pointe-claire","province":"QC","country":"Canada","name":"John","email":"join@gmail.com","telephone":"5555555555","note":"customer note","notification_language":"en","need_pick_up":"0 (no) or 1 (need pickup) or 2 (Inbound scan required) or 3 (need batch pickup)"}, }) req, _ := http.NewRequest("POST", "https://api.miliexpress.com/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.miliexpress.com/api/graphql', { method: 'POST', headers: { 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, body: JSON.stringify({ query: `mutation LabelserviceSubmitOrder($postcode: String, $street_number: String, $street_name: String, $apt: String, $buzz_code: String, $ref: String, $order_code: String, $city: String, $province: String, $country: String, $name: String, $email: String, $telephone: String, $note: String, $notification_language: String, $need_pick_up: Int) { labelserviceSubmitOrder(postcode: $postcode, street_number: $street_number, street_name: $street_name, apt: $apt, buzz_code: $buzz_code, ref: $ref, order_code: $order_code, city: $city, province: $province, country: $country, name: $name, email: $email, telephone: $telephone, note: $note, notification_language: $notification_language, need_pick_up: $need_pick_up) }`, variables: { "postcode": "H9S2H9", "street_number": "2667", "street_name": "boul des sources", "apt": "123", "buzz_code": "9393", "ref": "altima-4", "order_code": "ABC12", "city": "pointe-claire", "province": "QC", "country": "Canada", "name": "John", "email": "join@gmail.com", "telephone": "5555555555", "note": "customer note", "notification_language": "en", "need_pick_up": "0 (no) or 1 (need pickup) or 2 (Inbound scan required) or 3 (need batch pickup)" }, }), }); const data = await response.json(); console.log(data);

import java.net.http.*; import java.net.URI; HttpClient client = HttpClient.newHttpClient(); String body = "{\"query\":\"mutation LabelserviceSubmitOrder($postcode: String, $street_number: String, $street_name: String, $apt: String, $buzz_code: String, $ref: String, $order_code: String, $city: String, $province: String, $country: String, $name: String, $email: String, $telephone: String, $note: String, $notification_language: String, $need_pick_up: Int) {\\n labelserviceSubmitOrder(postcode: $postcode, street_number: $street_number, street_name: $street_name, apt: $apt, buzz_code: $buzz_code, ref: $ref, order_code: $order_code, city: $city, province: $province, country: $country, name: $name, email: $email, telephone: $telephone, note: $note, notification_language: $notification_language, need_pick_up: $need_pick_up)\\n}\",\"variables\":{\"postcode\":\"H9S2H9\",\"street_number\":\"2667\",\"street_name\":\"boul des sources\",\"apt\":\"123\",\"buzz_code\":\"9393\",\"ref\":\"altima-4\",\"order_code\":\"ABC12\",\"city\":\"pointe-claire\",\"province\":\"QC\",\"country\":\"Canada\",\"name\":\"John\",\"email\":\"join@gmail.com\",\"telephone\":\"5555555555\",\"note\":\"customer note\",\"notification_language\":\"en\",\"need_pick_up\":\"0 (no) or 1 (need pickup) or 2 (Inbound scan required) or 3 (need batch pickup)\"}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.miliexpress.com/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.miliexpress.com/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 LabelserviceSubmitOrder($postcode: String, $street_number: String, $street_name: String, $apt: String, $buzz_code: String, $ref: String, $order_code: String, $city: String, $province: String, $country: String, $name: String, $email: String, $telephone: String, $note: String, $notification_language: String, $need_pick_up: Int) { labelserviceSubmitOrder(postcode: $postcode, street_number: $street_number, street_name: $street_name, apt: $apt, buzz_code: $buzz_code, ref: $ref, order_code: $order_code, city: $city, province: $province, country: $country, name: $name, email: $email, telephone: $telephone, note: $note, notification_language: $notification_language, need_pick_up: $need_pick_up) }', variables: {"postcode":"H9S2H9","street_number":"2667","street_name":"boul des sources","apt":"123","buzz_code":"9393","ref":"altima-4","order_code":"ABC12","city":"pointe-claire","province":"QC","country":"Canada","name":"John","email":"join@gmail.com","telephone":"5555555555","note":"customer note","notification_language":"en","need_pick_up":"0 (no) or 1 (need pickup) or 2 (Inbound scan required) or 3 (need batch pickup)"} }) response = http.request(request) puts JSON.parse(response.body)

<?php require 'vendor/autoload.php'; $client = new GuzzleHttp\Client(); $response = $client->post('https://api.miliexpress.com/api/graphql', [ 'headers' => [ 'Content-Type' => 'application/json', 'Accept' => 'application/json', 'Authorization' => 'Bearer YOUR_TOKEN', ], 'json' => [ 'query' => 'mutation LabelserviceGetShippingDetail($postcode: String, $street_number: String, $street_name: String, $apt: String, $buzz_code: String, $ref: String, $city: String, $province: String, $country: String, $name: String, $email: String, $telephone: String, $note: String, $notification_language: String, $need_pick_up: Int) { labelserviceGetShippingDetail(postcode: $postcode, street_number: $street_number, street_name: $street_name, apt: $apt, buzz_code: $buzz_code, ref: $ref, city: $city, province: $province, country: $country, name: $name, email: $email, telephone: $telephone, note: $note, notification_language: $notification_language, need_pick_up: $need_pick_up) }', 'variables' => json_decode('{"postcode":"H9S2H9","street_number":"2667","street_name":"boul des sources","apt":"123","buzz_code":"9393","ref":"altima-4","city":"pointe-claire","province":"QC","country":"Canada","name":"John","email":"join@gmail.com","telephone":"5555555555","note":"customer note","notification_language":"en","need_pick_up":"0 (no) or 1 (need pickup) or 2 (Inbound scan required) or 3 (need batch pickup)"}', true), ], ]); $data = json_decode($response->getBody(), true); print_r($data);

import requests response = requests.post( 'https://api.miliexpress.com/api/graphql', headers={ 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, json={ 'query': 'mutation LabelserviceGetShippingDetail($postcode: String, $street_number: String, $street_name: String, $apt: String, $buzz_code: String, $ref: String, $city: String, $province: String, $country: String, $name: String, $email: String, $telephone: String, $note: String, $notification_language: String, $need_pick_up: Int) { labelserviceGetShippingDetail(postcode: $postcode, street_number: $street_number, street_name: $street_name, apt: $apt, buzz_code: $buzz_code, ref: $ref, city: $city, province: $province, country: $country, name: $name, email: $email, telephone: $telephone, note: $note, notification_language: $notification_language, need_pick_up: $need_pick_up) }', 'variables': {"postcode":"H9S2H9","street_number":"2667","street_name":"boul des sources","apt":"123","buzz_code":"9393","ref":"altima-4","city":"pointe-claire","province":"QC","country":"Canada","name":"John","email":"join@gmail.com","telephone":"5555555555","note":"customer note","notification_language":"en","need_pick_up":"0 (no) or 1 (need pickup) or 2 (Inbound scan required) or 3 (need batch pickup)"}, }, ) 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 LabelserviceGetShippingDetail($postcode: String, $street_number: String, $street_name: String, $apt: String, $buzz_code: String, $ref: String, $city: String, $province: String, $country: String, $name: String, $email: String, $telephone: String, $note: String, $notification_language: String, $need_pick_up: Int) { labelserviceGetShippingDetail(postcode: $postcode, street_number: $street_number, street_name: $street_name, apt: $apt, buzz_code: $buzz_code, ref: $ref, city: $city, province: $province, country: $country, name: $name, email: $email, telephone: $telephone, note: $note, notification_language: $notification_language, need_pick_up: $need_pick_up) }`, "variables": {"postcode":"H9S2H9","street_number":"2667","street_name":"boul des sources","apt":"123","buzz_code":"9393","ref":"altima-4","city":"pointe-claire","province":"QC","country":"Canada","name":"John","email":"join@gmail.com","telephone":"5555555555","note":"customer note","notification_language":"en","need_pick_up":"0 (no) or 1 (need pickup) or 2 (Inbound scan required) or 3 (need batch pickup)"}, }) req, _ := http.NewRequest("POST", "https://api.miliexpress.com/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.miliexpress.com/api/graphql', { method: 'POST', headers: { 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, body: JSON.stringify({ query: `mutation LabelserviceGetShippingDetail($postcode: String, $street_number: String, $street_name: String, $apt: String, $buzz_code: String, $ref: String, $city: String, $province: String, $country: String, $name: String, $email: String, $telephone: String, $note: String, $notification_language: String, $need_pick_up: Int) { labelserviceGetShippingDetail(postcode: $postcode, street_number: $street_number, street_name: $street_name, apt: $apt, buzz_code: $buzz_code, ref: $ref, city: $city, province: $province, country: $country, name: $name, email: $email, telephone: $telephone, note: $note, notification_language: $notification_language, need_pick_up: $need_pick_up) }`, variables: { "postcode": "H9S2H9", "street_number": "2667", "street_name": "boul des sources", "apt": "123", "buzz_code": "9393", "ref": "altima-4", "city": "pointe-claire", "province": "QC", "country": "Canada", "name": "John", "email": "join@gmail.com", "telephone": "5555555555", "note": "customer note", "notification_language": "en", "need_pick_up": "0 (no) or 1 (need pickup) or 2 (Inbound scan required) or 3 (need batch pickup)" }, }), }); const data = await response.json(); console.log(data);

import java.net.http.*; import java.net.URI; HttpClient client = HttpClient.newHttpClient(); String body = "{\"query\":\"mutation LabelserviceGetShippingDetail($postcode: String, $street_number: String, $street_name: String, $apt: String, $buzz_code: String, $ref: String, $city: String, $province: String, $country: String, $name: String, $email: String, $telephone: String, $note: String, $notification_language: String, $need_pick_up: Int) {\\n labelserviceGetShippingDetail(postcode: $postcode, street_number: $street_number, street_name: $street_name, apt: $apt, buzz_code: $buzz_code, ref: $ref, city: $city, province: $province, country: $country, name: $name, email: $email, telephone: $telephone, note: $note, notification_language: $notification_language, need_pick_up: $need_pick_up)\\n}\",\"variables\":{\"postcode\":\"H9S2H9\",\"street_number\":\"2667\",\"street_name\":\"boul des sources\",\"apt\":\"123\",\"buzz_code\":\"9393\",\"ref\":\"altima-4\",\"city\":\"pointe-claire\",\"province\":\"QC\",\"country\":\"Canada\",\"name\":\"John\",\"email\":\"join@gmail.com\",\"telephone\":\"5555555555\",\"note\":\"customer note\",\"notification_language\":\"en\",\"need_pick_up\":\"0 (no) or 1 (need pickup) or 2 (Inbound scan required) or 3 (need batch pickup)\"}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.miliexpress.com/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.miliexpress.com/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 LabelserviceGetShippingDetail($postcode: String, $street_number: String, $street_name: String, $apt: String, $buzz_code: String, $ref: String, $city: String, $province: String, $country: String, $name: String, $email: String, $telephone: String, $note: String, $notification_language: String, $need_pick_up: Int) { labelserviceGetShippingDetail(postcode: $postcode, street_number: $street_number, street_name: $street_name, apt: $apt, buzz_code: $buzz_code, ref: $ref, city: $city, province: $province, country: $country, name: $name, email: $email, telephone: $telephone, note: $note, notification_language: $notification_language, need_pick_up: $need_pick_up) }', variables: {"postcode":"H9S2H9","street_number":"2667","street_name":"boul des sources","apt":"123","buzz_code":"9393","ref":"altima-4","city":"pointe-claire","province":"QC","country":"Canada","name":"John","email":"join@gmail.com","telephone":"5555555555","note":"customer note","notification_language":"en","need_pick_up":"0 (no) or 1 (need pickup) or 2 (Inbound scan required) or 3 (need batch pickup)"} }) response = http.request(request) puts JSON.parse(response.body)

<?php require 'vendor/autoload.php'; $client = new GuzzleHttp\Client(); $response = $client->post('https://api.miliexpress.com/api/graphql', [ 'headers' => [ 'Content-Type' => 'application/json', 'Accept' => 'application/json', 'Authorization' => 'Bearer YOUR_TOKEN', ], 'json' => [ 'query' => 'mutation LabelserviceCancelShippingLabel($postcode: String, $street_number: String, $street_name: String, $apt: String, $buzz_code: String, $ref: String, $city: String, $province: String, $country: String, $name: String, $email: String, $telephone: String, $note: String, $notification_language: String, $need_pick_up: Int) { labelserviceCancelShippingLabel(postcode: $postcode, street_number: $street_number, street_name: $street_name, apt: $apt, buzz_code: $buzz_code, ref: $ref, city: $city, province: $province, country: $country, name: $name, email: $email, telephone: $telephone, note: $note, notification_language: $notification_language, need_pick_up: $need_pick_up) }', 'variables' => json_decode('{"postcode":"H9S2H9","street_number":"2667","street_name":"boul des sources","apt":"123","buzz_code":"9393","ref":"altima-4","city":"pointe-claire","province":"QC","country":"Canada","name":"John","email":"join@gmail.com","telephone":"5555555555","note":"customer note","notification_language":"en","need_pick_up":"0 (no) or 1 (need pickup) or 2 (Inbound scan required) or 3 (need batch pickup)"}', true), ], ]); $data = json_decode($response->getBody(), true); print_r($data);

import requests response = requests.post( 'https://api.miliexpress.com/api/graphql', headers={ 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, json={ 'query': 'mutation LabelserviceCancelShippingLabel($postcode: String, $street_number: String, $street_name: String, $apt: String, $buzz_code: String, $ref: String, $city: String, $province: String, $country: String, $name: String, $email: String, $telephone: String, $note: String, $notification_language: String, $need_pick_up: Int) { labelserviceCancelShippingLabel(postcode: $postcode, street_number: $street_number, street_name: $street_name, apt: $apt, buzz_code: $buzz_code, ref: $ref, city: $city, province: $province, country: $country, name: $name, email: $email, telephone: $telephone, note: $note, notification_language: $notification_language, need_pick_up: $need_pick_up) }', 'variables': {"postcode":"H9S2H9","street_number":"2667","street_name":"boul des sources","apt":"123","buzz_code":"9393","ref":"altima-4","city":"pointe-claire","province":"QC","country":"Canada","name":"John","email":"join@gmail.com","telephone":"5555555555","note":"customer note","notification_language":"en","need_pick_up":"0 (no) or 1 (need pickup) or 2 (Inbound scan required) or 3 (need batch pickup)"}, }, ) 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 LabelserviceCancelShippingLabel($postcode: String, $street_number: String, $street_name: String, $apt: String, $buzz_code: String, $ref: String, $city: String, $province: String, $country: String, $name: String, $email: String, $telephone: String, $note: String, $notification_language: String, $need_pick_up: Int) { labelserviceCancelShippingLabel(postcode: $postcode, street_number: $street_number, street_name: $street_name, apt: $apt, buzz_code: $buzz_code, ref: $ref, city: $city, province: $province, country: $country, name: $name, email: $email, telephone: $telephone, note: $note, notification_language: $notification_language, need_pick_up: $need_pick_up) }`, "variables": {"postcode":"H9S2H9","street_number":"2667","street_name":"boul des sources","apt":"123","buzz_code":"9393","ref":"altima-4","city":"pointe-claire","province":"QC","country":"Canada","name":"John","email":"join@gmail.com","telephone":"5555555555","note":"customer note","notification_language":"en","need_pick_up":"0 (no) or 1 (need pickup) or 2 (Inbound scan required) or 3 (need batch pickup)"}, }) req, _ := http.NewRequest("POST", "https://api.miliexpress.com/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.miliexpress.com/api/graphql', { method: 'POST', headers: { 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, body: JSON.stringify({ query: `mutation LabelserviceCancelShippingLabel($postcode: String, $street_number: String, $street_name: String, $apt: String, $buzz_code: String, $ref: String, $city: String, $province: String, $country: String, $name: String, $email: String, $telephone: String, $note: String, $notification_language: String, $need_pick_up: Int) { labelserviceCancelShippingLabel(postcode: $postcode, street_number: $street_number, street_name: $street_name, apt: $apt, buzz_code: $buzz_code, ref: $ref, city: $city, province: $province, country: $country, name: $name, email: $email, telephone: $telephone, note: $note, notification_language: $notification_language, need_pick_up: $need_pick_up) }`, variables: { "postcode": "H9S2H9", "street_number": "2667", "street_name": "boul des sources", "apt": "123", "buzz_code": "9393", "ref": "altima-4", "city": "pointe-claire", "province": "QC", "country": "Canada", "name": "John", "email": "join@gmail.com", "telephone": "5555555555", "note": "customer note", "notification_language": "en", "need_pick_up": "0 (no) or 1 (need pickup) or 2 (Inbound scan required) or 3 (need batch pickup)" }, }), }); const data = await response.json(); console.log(data);

import java.net.http.*; import java.net.URI; HttpClient client = HttpClient.newHttpClient(); String body = "{\"query\":\"mutation LabelserviceCancelShippingLabel($postcode: String, $street_number: String, $street_name: String, $apt: String, $buzz_code: String, $ref: String, $city: String, $province: String, $country: String, $name: String, $email: String, $telephone: String, $note: String, $notification_language: String, $need_pick_up: Int) {\\n labelserviceCancelShippingLabel(postcode: $postcode, street_number: $street_number, street_name: $street_name, apt: $apt, buzz_code: $buzz_code, ref: $ref, city: $city, province: $province, country: $country, name: $name, email: $email, telephone: $telephone, note: $note, notification_language: $notification_language, need_pick_up: $need_pick_up)\\n}\",\"variables\":{\"postcode\":\"H9S2H9\",\"street_number\":\"2667\",\"street_name\":\"boul des sources\",\"apt\":\"123\",\"buzz_code\":\"9393\",\"ref\":\"altima-4\",\"city\":\"pointe-claire\",\"province\":\"QC\",\"country\":\"Canada\",\"name\":\"John\",\"email\":\"join@gmail.com\",\"telephone\":\"5555555555\",\"note\":\"customer note\",\"notification_language\":\"en\",\"need_pick_up\":\"0 (no) or 1 (need pickup) or 2 (Inbound scan required) or 3 (need batch pickup)\"}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.miliexpress.com/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.miliexpress.com/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 LabelserviceCancelShippingLabel($postcode: String, $street_number: String, $street_name: String, $apt: String, $buzz_code: String, $ref: String, $city: String, $province: String, $country: String, $name: String, $email: String, $telephone: String, $note: String, $notification_language: String, $need_pick_up: Int) { labelserviceCancelShippingLabel(postcode: $postcode, street_number: $street_number, street_name: $street_name, apt: $apt, buzz_code: $buzz_code, ref: $ref, city: $city, province: $province, country: $country, name: $name, email: $email, telephone: $telephone, note: $note, notification_language: $notification_language, need_pick_up: $need_pick_up) }', variables: {"postcode":"H9S2H9","street_number":"2667","street_name":"boul des sources","apt":"123","buzz_code":"9393","ref":"altima-4","city":"pointe-claire","province":"QC","country":"Canada","name":"John","email":"join@gmail.com","telephone":"5555555555","note":"customer note","notification_language":"en","need_pick_up":"0 (no) or 1 (need pickup) or 2 (Inbound scan required) or 3 (need batch pickup)"} }) response = http.request(request) puts JSON.parse(response.body)

<?php require 'vendor/autoload.php'; $client = new GuzzleHttp\Client(); $response = $client->post('https://api.miliexpress.com/api/graphql', [ 'headers' => [ 'Content-Type' => 'application/json', 'Accept' => 'application/json', 'Authorization' => 'Bearer YOUR_TOKEN', ], 'json' => [ 'query' => 'mutation LabelserviceUploadShippingLabel($id: Int, $shippingLabel: String, $packages: [String]) { labelserviceUploadShippingLabel(id: $id, shippingLabel: $shippingLabel, packages: $packages) }', 'variables' => json_decode('{"id":1,"shippingLabel":"example_file","packages":[{"id":112343,"tracking_number":"123456789012"},{"id":112344,"tracking_number":"123456789013"}]}', true), ], ]); $data = json_decode($response->getBody(), true); print_r($data);

import requests response = requests.post( 'https://api.miliexpress.com/api/graphql', headers={ 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, json={ 'query': 'mutation LabelserviceUploadShippingLabel($id: Int, $shippingLabel: String, $packages: [String]) { labelserviceUploadShippingLabel(id: $id, shippingLabel: $shippingLabel, packages: $packages) }', 'variables': {"id":1,"shippingLabel":"example_file","packages":[{"id":112343,"tracking_number":"123456789012"},{"id":112344,"tracking_number":"123456789013"}]}, }, ) 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 LabelserviceUploadShippingLabel($id: Int, $shippingLabel: String, $packages: [String]) { labelserviceUploadShippingLabel(id: $id, shippingLabel: $shippingLabel, packages: $packages) }`, "variables": {"id":1,"shippingLabel":"example_file","packages":[{"id":112343,"tracking_number":"123456789012"},{"id":112344,"tracking_number":"123456789013"}]}, }) req, _ := http.NewRequest("POST", "https://api.miliexpress.com/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.miliexpress.com/api/graphql', { method: 'POST', headers: { 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, body: JSON.stringify({ query: `mutation LabelserviceUploadShippingLabel($id: Int, $shippingLabel: String, $packages: [String]) { labelserviceUploadShippingLabel(id: $id, shippingLabel: $shippingLabel, packages: $packages) }`, variables: { "id": 1, "shippingLabel": "example_file", "packages": [ { "id": 112343, "tracking_number": "123456789012" }, { "id": 112344, "tracking_number": "123456789013" } ] }, }), }); const data = await response.json(); console.log(data);

import java.net.http.*; import java.net.URI; HttpClient client = HttpClient.newHttpClient(); String body = "{\"query\":\"mutation LabelserviceUploadShippingLabel($id: Int, $shippingLabel: String, $packages: [String]) {\\n labelserviceUploadShippingLabel(id: $id, shippingLabel: $shippingLabel, packages: $packages)\\n}\",\"variables\":{\"id\":1,\"shippingLabel\":\"example_file\",\"packages\":[{\"id\":112343,\"tracking_number\":\"123456789012\"},{\"id\":112344,\"tracking_number\":\"123456789013\"}]}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.miliexpress.com/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.miliexpress.com/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 LabelserviceUploadShippingLabel($id: Int, $shippingLabel: String, $packages: [String]) { labelserviceUploadShippingLabel(id: $id, shippingLabel: $shippingLabel, packages: $packages) }', variables: {"id":1,"shippingLabel":"example_file","packages":[{"id":112343,"tracking_number":"123456789012"},{"id":112344,"tracking_number":"123456789013"}]} }) response = http.request(request) puts JSON.parse(response.body)

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

import requests response = requests.post( 'https://api.miliexpress.com/api/graphql', headers={ 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, json={ 'query': 'mutation LabelserviceGetShippingLabel($id: String, $type: String, $packages: Int) { labelserviceGetShippingLabel(id: $id, type: $type, packages: $packages) }', 'variables': {"id":"17341","type":"TRACKING_NUMBER","packages":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 LabelserviceGetShippingLabel($id: String, $type: String, $packages: Int) { labelserviceGetShippingLabel(id: $id, type: $type, packages: $packages) }`, "variables": {"id":"17341","type":"TRACKING_NUMBER","packages":1}, }) req, _ := http.NewRequest("POST", "https://api.miliexpress.com/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.miliexpress.com/api/graphql', { method: 'POST', headers: { 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, body: JSON.stringify({ query: `mutation LabelserviceGetShippingLabel($id: String, $type: String, $packages: Int) { labelserviceGetShippingLabel(id: $id, type: $type, packages: $packages) }`, variables: { "id": "17341", "type": "TRACKING_NUMBER", "packages": 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 LabelserviceGetShippingLabel($id: String, $type: String, $packages: Int) {\\n labelserviceGetShippingLabel(id: $id, type: $type, packages: $packages)\\n}\",\"variables\":{\"id\":\"17341\",\"type\":\"TRACKING_NUMBER\",\"packages\":1}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.miliexpress.com/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.miliexpress.com/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 LabelserviceGetShippingLabel($id: String, $type: String, $packages: Int) { labelserviceGetShippingLabel(id: $id, type: $type, packages: $packages) }', variables: {"id":"17341","type":"TRACKING_NUMBER","packages":1} }) response = http.request(request) puts JSON.parse(response.body)

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

import requests response = requests.post( 'https://api.miliexpress.com/api/graphql', headers={ 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, json={ 'query': 'mutation LabelserviceGetShippingMethodList { labelserviceGetShippingMethodList }', '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 LabelserviceGetShippingMethodList { labelserviceGetShippingMethodList }`, "variables": map[string]interface{}{}, }) req, _ := http.NewRequest("POST", "https://api.miliexpress.com/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.miliexpress.com/api/graphql', { method: 'POST', headers: { 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, body: JSON.stringify({ query: `mutation LabelserviceGetShippingMethodList { labelserviceGetShippingMethodList }`, 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 LabelserviceGetShippingMethodList {\\n labelserviceGetShippingMethodList\\n}\",\"variables\":{}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.miliexpress.com/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.miliexpress.com/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 LabelserviceGetShippingMethodList { labelserviceGetShippingMethodList }', variables: {} }) response = http.request(request) puts JSON.parse(response.body)

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

import requests response = requests.post( 'https://api.miliexpress.com/api/graphql', headers={ 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, json={ 'query': 'mutation LabelserviceEndofday { labelserviceEndofday }', '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 LabelserviceEndofday { labelserviceEndofday }`, "variables": map[string]interface{}{}, }) req, _ := http.NewRequest("POST", "https://api.miliexpress.com/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.miliexpress.com/api/graphql', { method: 'POST', headers: { 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, body: JSON.stringify({ query: `mutation LabelserviceEndofday { labelserviceEndofday }`, 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 LabelserviceEndofday {\\n labelserviceEndofday\\n}\",\"variables\":{}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.miliexpress.com/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.miliexpress.com/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 LabelserviceEndofday { labelserviceEndofday }', variables: {} }) response = http.request(request) puts JSON.parse(response.body)

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

import requests response = requests.post( 'https://api.miliexpress.com/api/graphql', headers={ 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, json={ 'query': 'mutation OcrLabel($file: String) { ocrLabel(file: $file) }', 'variables': {"file":"base64encodeddata"}, }, ) 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 OcrLabel($file: String) { ocrLabel(file: $file) }`, "variables": {"file":"base64encodeddata"}, }) req, _ := http.NewRequest("POST", "https://api.miliexpress.com/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.miliexpress.com/api/graphql', { method: 'POST', headers: { 'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': 'Bearer YOUR_TOKEN', }, body: JSON.stringify({ query: `mutation OcrLabel($file: String) { ocrLabel(file: $file) }`, variables: { "file": "base64encodeddata" }, }), }); const data = await response.json(); console.log(data);

import java.net.http.*; import java.net.URI; HttpClient client = HttpClient.newHttpClient(); String body = "{\"query\":\"mutation OcrLabel($file: String) {\\n ocrLabel(file: $file)\\n}\",\"variables\":{\"file\":\"base64encodeddata\"}}"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.miliexpress.com/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.miliexpress.com/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 OcrLabel($file: String) { ocrLabel(file: $file) }', variables: {"file":"base64encodeddata"} }) response = http.request(request) puts JSON.parse(response.body)