Packeta

https://docs.packeta.com/docs
Admin
Packeta is a digital platform and packet delivery solution that enables delivery to home addresses...
Tokens:153,055
Snippets:1,033
Trust Score:9.8
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### Initialize SOAP client and API password

Source: https://docs.packeta.com/docs/api-reference/api-methods

Prerequisite setup for all API method examples. Creates a SoapClient instance and defines the API password variable.

```php
<?php  
  
$client = new SoapClient("https://soap.api.packeta.com/api/soap-php-bugfix.wsdl"); // initialize the client  
$pw = "1234567890abcdef1234567890abcdef"; // API password  

```

--------------------------------

### Python requests with Brotli compression

Source: https://docs.packeta.com/docs/pudo-delivery/feed-optimization

Python example using the requests library to fetch a Brotli-compressed feed. The client must support Brotli decompression; requests does this automatically when the brotli package is installed.

```python
import requests

response = requests.get(
    "https://pickup-point.api.packeta.com/v5/__API_KEY__/branch/json",
    headers={
        "X-Api-Key": "YOUR_API_KEY",
        "Accept-Encoding": "br",
    },
)
response.raise_for_status()
data = response.json()
```

--------------------------------

### C# Client Example

Source: https://docs.packeta.com/docs/label-printing/packeta-label

C# example using a generated client to call packetLabelZpl and save the result to a file.

```APIDOC
## [SOAP] packetLabelZpl (C#)

### Description
C# example demonstrating how to call the packetLabelZpl SOAP method using a generated client and save the label to a file.

### Method
SOAP

### Endpoint
https://www.zasilkovna.cz/api/soap

### Parameters
- **apiPassword** (string) - Required - The API password.
- **packetId** (ulong) - Required - The packet ID.
- **dpi** (uint) - Required - The DPI value.

### Request Example
```csharp
using System;
using System.ServiceModel;
using System.Threading.Tasks;
using PacketaService;
using System.IO;

namespace PacketaClientExample
{
    class Program
    {
        static async Task Main(string[] args)
        {
            BasicHttpsBinding binding = new BasicHttpsBinding() { MaxReceivedMessageSize = int.MaxValue };
            EndpointAddress endpointAddress = new EndpointAddress("https://www.zasilkovna.cz/api/soap");

            string apiPassword = "apiPassword";
            ulong packetId = 1234567890;
            uint dpi = 300;

            PacketaClient client = new PacketaClient(binding, endpointAddress);
            try
            {
                packetLabelZplResponse response = await client.packetLabelZplAsync(
                    new packetLabelZplRequest(apiPassword, packetId, dpi)
                );

                //Process response
                await File.WriteAllTextAsync("./label.zpl", response.packetLabelZplResult);
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);
            }
        }
    }
}
```

### Response
#### Success Response (200)
- **packetLabelZplResult** (string) - The ZPL label content.

#### Response Example
(Not provided in source)
```

--------------------------------

### PHP SoapClient Example

Source: https://docs.packeta.com/docs/label-printing/packeta-label

PHP example using SoapClient to call packetLabelZpl and output the result.

```APIDOC
## [SOAP] packetLabelZpl (PHP)

### Description
PHP example demonstrating how to call the packetLabelZpl SOAP method using the SoapClient class.

### Method
SOAP

### Endpoint
https://www.zasilkovna.cz/api/soap.wsdl

### Parameters
- **apiPassword** (string) - Required - The API password.
- **packetId** (string) - Required - The packet ID.
- **dpi** (int) - Required - The DPI value.

### Request Example
```php
<?php

$apiPassword = "apiPassword";
$packetId = "1234567890";
$dpi = 203;

try {
    $client = new SoapClient("https://www.zasilkovna.cz/api/soap.wsdl");
    $result = $client->packetLabelZpl($apiPassword, $packetId, $dpi);
    var_dump($result);
} catch (SoapFault $e) {
    echo $e->getMessage();
}

?>
```

### Response
#### Success Response (200)
- **packetLabelZplResult** (string) - The ZPL label content.

#### Response Example
(Not provided in source)
```

--------------------------------

### senderGetReturnRouting() - Get return routing strings

Source: https://docs.packeta.com/docs/api-reference/api-methods

Returns two return routing strings for a sender. The PHP example calls senderGetReturnRouting() with a sender label and catches SoapFault; the XML shows the SOAP request structure. Possible error: SenderNotExists. The strings are generated from account settings and should be downloaded each time; print them on separate lines per label specifications.

```php
<?php  
  
$senderLabel = 'my-eshop';  
  
try {  
	$client->senderGetReturnRouting($pw, $senderLabel);  
} catch (SoapFault $e) {  
	...  
}  

```

```xml
<senderGetReturnRouting>  
	<apiPassword>...</apiPassword>  
	<senderLabel>my-eshop</senderLabel>  
</senderGetReturnRouting>  

```

--------------------------------

### C# client example for packetCourierLabelPng

Source: https://docs.packeta.com/docs/label-printing/carrier-label

C# example using a generated PacketaClient to call packetCourierLabelPngAsync. It writes the returned PNG to label.png and catches exceptions.

```C#
using System;  
using System.ServiceModel;  
using System.Threading.Tasks;  
using PacketaService;  
using System.IO;  
  
namespace PacketaClientExample  
{  
    class Program  
    {  
        static async Task Main(string[] args)  
        {  
            BasicHttpsBinding binding = new BasicHttpsBinding() { MaxReceivedMessageSize = int.MaxValue };  
            EndpointAddress endpointAddress = new EndpointAddress("https://www.zasilkovna.cz/api/soap");  
  
            string apiPassword = "apiPassword";  
            ulong packetId = 1234567890;  
            string courierNumber = "5451339442605";  
  
            PacketaClient client = new PacketaClient(binding, endpointAddress);  
            try  
            {  
                packetCourierLabelPngResponse response = await client.packetCourierLabelPngAsync(  
                    new packetCourierLabelPngRequest(apiPassword, packetId, courierNumber)  
                );  
  
                //Process response  
                await File.WriteAllBytesAsync("./label.png", response.packetCourierLabelPngResult);  
            }  
            catch (Exception e)  
            {  
                Console.WriteLine(e.Message);  
            }  
        }  
    }  
}  
  

```

--------------------------------

### PHP SoapClient example for packetCourierLabelPng

Source: https://docs.packeta.com/docs/label-printing/carrier-label

PHP example using SoapClient to call packetCourierLabelPng. It writes the returned PNG data to label.png and prints any SoapFault message.

```PHP
<?php  
  
$apiPassword = 'apiPassword';  
$packetId = '4318560169';  
$courierNumber = '994717547550625744';  
  
try {  
    $client = new SoapClient('https://www.zasilkovna.cz/api/soap.wsdl');  
    $result = $client->packetCourierLabelPng($apiPassword, $packetId, $courierNumber);  
  
    header('Content-Type: image/png');  
    echo $result;  
} catch (SoapFault $e) {  
    echo $e->getMessage();  
}  
  
?>  
  

```

--------------------------------

### packetLabelPdf() request/response examples

Source: https://docs.packeta.com/docs/label-printing/packeta-label

Example request/response for the packetLabelPdf() method, shown in REST, SOAP, PHP, C#, and Node.js. The REST and SOAP blocks include both the request and the response. The PHP and C# examples use the SOAP endpoint, while the Node.js example uses the REST endpoint. The response contains a base64-encoded PDF label.

```XML
<!--request-->
<packetLabelPdf>
    <apiPassword>{{API_PASSWORD}}</apiPassword>
    <packetId>1234567890</packetId>
    <format>A6 on A6</format>
    <offset>0</offset>
</packetLabelPdf>


<!--response-->
<response>
    <status>ok</status>
    <result>JVBERi0xLjcKJeLjz9MKNyAwIG9iago8P.....NDU1PiBdID4+CnN0YXJ0eHJlZgo4ODE1NwolJUVPRgo=</result>
</response>
```

```XML
<!--request-->
<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:soap="http://www.zasilkovna.cz/api/soap.wsdl2">
   <soapenv:Header/>
   <soapenv:Body>
      <soap:packetLabelPdf>
         <apiPassword>{{API_PASSWORD}}</apiPassword>
         <packetId>1234567890</packetId>
         <format>A6 on A6</format>
         <offset>0</offset>
      </soap:packetLabelPdf>
   </soapenv:Body>
</soapenv:Envelope>


<!--response-->
<SOAP-ENV:Envelope xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/" xmlns:ns1="http://www.zasilkovna.cz/api/soap.wsdl">
   <SOAP-ENV:Body>
      <ns1:packetLabelPdfResponse>
         <packetLabelPdfResult>JVBERi0xLjcKJeLjz9MKNyAwIG9iago8.....PCAvVHVmCjc4OTU5CiUlRU9GCg==</packetLabelPdfResult>
      </ns1:packetLabelPdfResponse>
   </SOAP-ENV:Body>
</SOAP-ENV:Envelope>
```

```PHP
<?php

$apiPassword = 'apiPasswordx';
$packetId = '1234567890';
$format = 'A6 on A6';
$offset = 0;

try {
    $client = new SoapClient("https://soap.api.packeta.com/api/soap.wsdl");
    $result = $client->packetLabelPdf($apiPassword, $packetId, $format, $offset);

    header('Content-Type: application/pdf');
    echo $result;
} catch (SoapFault $e) {
    echo $e->getMessage();
}
```

```C#
using System;
using System.ServiceModel;
using System.Threading.Tasks;
using PacketaService;
using System.IO;

namespace PacketaClientExample
{
    class Program
    {
        static async Task Main(string[] args)
        {
            BasicHttpsBinding binding = new BasicHttpsBinding() { MaxReceivedMessageSize = int.MaxValue };
            EndpointAddress endpointAddress = new EndpointAddress("https://www.zasilkovna.cz/api/soap");

            string apiPassword = "apiPassword";
            ulong packetId = 1234567890;
            string format = "A6 on A6";
            uint offset = 0;

            PacketaClient client = new PacketaClient(binding, endpointAddress);
            try
            {
                packetLabelPdfResponse response = await client.packetLabelPdfAsync(
                    new packetLabelPdfRequest(apiPassword, packetId, format, offset)
                );

                //Process response
                await File.WriteAllBytesAsync("./label.pdf", response.packetLabelPdfResult);
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);
            }
        }
    }
}
```

```Node.js
import { Builder, Parser } from "xml2js"
import * as fs from "node:fs/promises"

const requestBody = {
    packetLabelPdf: {
        apiPassword: "apiPassword",
        packetId: "1234567890",
        format: "A6 on A6",
        offset: 0
    }
}

try {
    const response = await fetch(
        "https://www.zasilkovna.cz/api/rest",
        {
            method: "POST",
            body: new Builder().buildObject(requestBody)
        }
    );

    const responseBody = await new Parser({ explicitArray: false }).parseStringPromise(await response.text());

    //process response
    if(responseBody.response.status === "ok") {
        await fs.writeFile("label.pdf", Buffer.from(responseBody.response.result, 'base64'));
    }
}
catch (exception) {
    console.log(exception);
}
```

--------------------------------

### Node.js example for packetsCourierLabelsPdf

Source: https://docs.packeta.com/docs/label-printing/carrier-label

Node.js example using xml2js to build a request for packetsCourierLabelsPdf. It writes the returned base64 PDF to label.png and logs any exception.

```JavaScript
import { Builder, Parser } from "xml2js";  
import * as fs from "node:fs/promises";  
  
const requestBody = {  
  packetCourierLabelPng: {  
    apiPassword: "apiPassword",  
    packetId: "4318560169",  
    courierNumber: "994717547550625744",  
  },  
};  
  
try {  
  const response = await fetch("https://www.zasilkovna.cz/api/rest", {  
    method: "POST",  
    body: new Builder().buildObject(requestBody),  
  });  
  
  const responseBody = await new Parser({  
    explicitArray: false,  
  }).parseStringPromise(await response.text());  
  
  //process response  
  if (responseBody.response.status === "ok") {  
    await fs.writeFile(  
      "label.png",  
      Buffer.from(responseBody.response.result, "base64")  
    );  
  }  
} catch (exception) {  
  console.log(exception);  
}  
  

```

--------------------------------

### packetTracking() REST request/response example

Source: https://docs.packeta.com/docs/packet-tracking/tracking

Example REST request and response for the packetTracking() method. The request uses the API password and packet ID. The response contains a list of tracking records with status codes and timestamps.

```xml
  
<!--request-->  
<packetTracking>  
    <apiPassword>{{API_PASSWORD}}</apiPassword>  
    <packetId>Z1234567890</packetId>  
</packetTracking>  
  
<!--response-->  
<response>  
  <status>ok</status>  
  <result>  
    <record>  
      <dateTime>2022-01-06T11:43:09</dateTime>  
      <statusCode>1</statusCode>  
      <codeText>received data</codeText>  
      <statusText>Internetový obchod předal informace o zásilce.</statusText>  
      <branchId>0</branchId>  
      <destinationBranchId>0</destinationBranchId>  
      <externalTrackingCode></externalTrackingCode>  
    </record>  
    <record>  
      <dateTime>2022-01-07T12:44:43</dateTime>  
      <statusCode>2</statusCode>  
      <codeText>arrived</codeText>  
      <statusText>Zásilka byla přijata na pobočce Zásilkovna, Packeta office - pouze pro zaměstnance.</statusText>  
      <branchId>1038</branchId>  
      <destinationBranchId>0</destinationBranchId>  
      <externalTrackingCode></externalTrackingCode>  
    </record>  
    <record>  
      <dateTime>2022-01-07T12:44:44</dateTime>  
      <statusCode>3</statusCode>  
      <codeText>prepared for departure</codeText>  
      <statusText>Zásilka byla připravena k odeslání na pobočce Zásilkovna, Packeta office - pouze pro zaměstnance.</statusText>  
      <branchId>1038</branchId>  
      <destinationBranchId>13497</destinationBranchId>  
      <externalTrackingCode></externalTrackingCode>  
    </record>  
    <record>  
      <dateTime>2022-01-07T14:12:11</dateTime>  
      <statusCode>3</statusCode>  
      <codeText>prepared for departure</codeText>  
      <statusText>Zásilka byla připravena k odeslání na depu Zásilkovna, DEPO, Praha - Štěrboholy, K Hrušovu 292/4.</statusText>  
      <branchId>13497</branchId>  
      <destinationBranchId>13854</destinationBranchId>  
      <externalTrackingCode></externalTrackingCode>  
    </record>  
    <record>  
      <dateTime>2022-01-07T14:14:19</dateTime>  
      <statusCode>2</statusCode>  
      <codeText>arrived</codeText>  
      <statusText>Zásilka byla přijata na depu Zásilkovna, DEPO, Praha - Štěrboholy, K Hrušovu 292/4.</statusText>  
      <branchId>13497</branchId>  
      <destinationBranchId>0</destinationBranchId>  
      <externalTrackingCode></externalTrackingCode>  
    </record>  
    <record>  
      <dateTime>2022-01-10T00:23:08</dateTime>  
    </record>  
  </result>  
</response>  
```

--------------------------------

### C# WCF createPacketClaimWithPasswordAsync

Source: https://docs.packeta.com/docs/packet-creation/returns

C# WCF example for creating a packet claim with password. Uses BasicHttpsBinding and PacketaClient to call createPacketClaimWithPasswordAsync. The example response shows the returned id, barcode, barcodeText, and password.

```csharp
using System;  
using System.ServiceModel;  
using System.Threading.Tasks;  
using PacketaService;  
  
namespace PacketaClientExample  
{  
    class Program  
    {  
        static async Task Main(string[] args)  
        {  
            BasicHttpsBinding binding = new BasicHttpsBinding();  
            EndpointAddress endpointAddress = new EndpointAddress("https://www.zasilkovna.cz/api/soap");  
  
            const string apiPassword = "apiPassword";  
            ClaimWithPasswordAttributes claimAttributes = new ClaimWithPasswordAttributes  
            {  
                phone = "+48698183000",  
                email = "example@packetatest.com",  
                value = 100,  
                eshop = "MyEshop",  
                number = "orderNumber",  
                currency = "CZK",  
                sendEmailToCustomer = false  
            };  
  
            PacketaClient client = new PacketaClient(binding, endpointAddress);  
  
            try  
            {  
                createPacketClaimWithPasswordResponse response =  
                    await client.createPacketClaimWithPasswordAsync(  
                        new createPacketClaimWithPasswordRequest(  
                            apiPassword,  
                            claimAttributes  
                        )  
                    );  
  
                // Process response  
                Console.WriteLine(response.createPacketClaimWithPasswordResult.id);  
                Console.WriteLine(response.createPacketClaimWithPasswordResult.barcode);  
                Console.WriteLine(response.createPacketClaimWithPasswordResult.barcodeText);  
                Console.WriteLine(response.createPacketClaimWithPasswordResult.password);  
            }  
            catch (Exception e)  
            {  
                Console.WriteLine(e.Message);  
            }  
        }  
    }  
}  
  
/*  
Example response:  
id: 1234567890  
barcode: Z1234567890  
barcodeText: Z 123 4567 890  
password: 123456789  
*/  

```

--------------------------------

### Packeta.Widget.pick(apiKey, callback, options, inElement)

Source: https://docs.packeta.com/docs/home-delivery/widget

Launches the Packeta home delivery widget.

```APIDOC
## Packeta.Widget.pick(apiKey, callback, options, inElement)

### Description
Launches the Packeta home delivery widget. There is no return value.

### Method
Function call

### Endpoint
Packeta.Widget.pick(apiKey, callback, options, inElement)

### Parameters
- **apiKey** (string[16]) - Required - An identifier of your Packeta account, available in Packeta Client section, or can be provided by your account manager.
- **callback** (function) - Required - Function which will be called when the user confirms or cancels delivery address selection. The function will receive one argument, which will be either an Return values object if delivery address was selected, or null if selection was cancelled.
- **options** (Object Options) - Required - Additional configuration options of the application, see below.
- **inElement** (DOM element) - Optional - If not null, application will be displayed inside the specified DOM element. We recommend that the element has dimensions specified.

### Request Example
```javascript
Packeta.Widget.pick(apiKey, callback, options, inElement);
```

### Response
No return value.
```

--------------------------------

### Get courier number with packetCourierNumber (deprecated)

Source: https://docs.packeta.com/docs/api-reference/api-methods

Deprecated method that returns a courier number if the external carrier allows it (apiAllowed=true). Possible errors: PacketIdFault, NotSupportedFault, ExternalGatewayFault. The PHP example shows a try-catch block.

```PHP
<?php  
  
$packetId = '1234567890';  
  
try {  
	$client->packetCourierNumber($pw, $packetId);  
} catch (SoapFault $e) {  
	...  
}  

```

```XML
<packetCourierNumber>  
	<apiPassword>...</apiPassword>  
	<packetId>1234567890</packetId>  
</packetCourierNumber>  

```

--------------------------------

### packetStatus() - Get current packet status

Source: https://docs.packeta.com/docs/api-reference/api-methods

Fetches the current status of a packet by its ID. The PHP example calls packetStatus() with a packet ID and catches SoapFault; the XML shows the SOAP request structure. Possible error: PacketIdFault.

```php
<?php  
  
$packetId = '1234567890';  
  
try {  
	$client->packetStatus($pw, $packetId);  
} catch (SoapFault $e) {  
	...  
}  

```

```xml
<packetStatus>  
	<apiPassword>...</apiPassword>  
	<packetId>1234567890</packetId>  
</packetStatus>  

```

--------------------------------

### shipmentPackets() - Get packets in a shipment

Source: https://docs.packeta.com/docs/api-reference/api-methods

Finds packets inside a shipment identified by D-code or B-code. The PHP example calls shipmentPackets() with a shipment ID and catches SoapFault; the XML shows the SOAP request structure. Possible error: ShipmentNotFoundFault.

```php
<?php  
  
$shipmentId = 'D-***-XM-12345678';  
  
try {  
	$client->shipmentPackets($pw, $shipmentId);  
} catch (SoapFault $e) {  
	...  
}  

```

```xml
<shipmentPackets>  
    <apiPassword>...</apiPassword>  
    <shipmentId>D-***-XM-12345678</shipmentId>  
</shipmentPackets>  

```

--------------------------------

### packetTracking() - Get packet tracking history

Source: https://docs.packeta.com/docs/api-reference/api-methods

Fetches the full tracking history of a packet by its ID. The PHP example calls packetTracking() with a packet ID and catches SoapFault; the XML shows the SOAP request structure. Possible error: PacketIdFault.

```php
<?php  
  
$packetId = '1234567890';  
  
try {  
	$client->packetTracking($pw, $packetId);  
} catch (SoapFault $e) {  
	...  
}  

```

```xml
<packetTracking>  
	<apiPassword>...</apiPassword>  
	<packetId>1234567890</packetId>  
</packetTracking>  

```

--------------------------------

### PHP createPacket with SoapClient

Source: https://docs.packeta.com/docs/packet-creation/packeta-pudos

PHP example using SoapClient to call createPacket with the PUDO addressId. It catches SoapFault and inspects PacketAttributesFault or IncorrectApiPasswordFault details.

```PHP
<?php

$apiPassword = 'apiPassword';

$packetAttributes = [
    'number' => '20220513001',
    'name' => 'John',
    'surname' => 'Doe',
    'company' => 'Company',
    'email' => 'example@packetatest.com',
    'phone' => '+420777123456',
    'addressId' => 52,
    'cod' => 115,
    'value' => '115',
    'currency' => 'CZK',
    'weight' => 2.5,
    'eshop' => 'MyEshop',
];

try {
    $client = new SoapClient('https://www.zasilkovna.cz/api/soap.wsdl');
    $result = $client->createPacket($apiPassword, $packetAttributes);

    var_dump($result);
} catch (SoapFault $e) {
    echo $e->getMessage();

    if (isset($e->detail->PacketAttributesFault)) {
        var_dump($e->detail->PacketAttributesFault->attributes->fault);
    } elseif (isset($e->detail->IncorrectApiPasswordFault)) {
        var_dump('Incorrect API password.');
    }
}
?>
```

--------------------------------

### SOAP createPacket()

Source: https://docs.packeta.com/docs/getting-started/packeta-api

Example of creating a packet via the SOAP interface.

```APIDOC
## [SOAP] createPacket()

### Description
Creates a packet using the SOAP interface. The method is called on the SOAP client with the API password and packet attributes.

### Method
SOAP

### Endpoint
WSDL: https://www.zasilkovna.cz/api/soap.wsdl
WSDL for PHP (32-bit): https://www.zasilkovna.cz/api/soap-php-bugfix.wsdl

### Parameters
#### Arguments
- **apiPassword** (string) - Required - API password for authentication.
- **attrs** (PacketAttributes) - Required - Packet attributes object containing:
  - **number** (string) - Required - Packet number.
  - **name** (string) - Required - Recipient's first name.
  - **surname** (string) - Required - Recipient's surname.
  - **email** (string) - Required - Recipient's email address.
  - **phone** (string) - Required - Recipient's phone number.
  - **addressId** (integer) - Required - ID of the pickup point or address.
  - **cod** (decimal) - Optional - Cash on delivery amount.
  - **value** (decimal) - Optional - Declared value of the packet.
  - **weight** (decimal) - Required - Weight of the packet in kilograms.
  - **eshop** (string) - Required - Sender indication (eshop identifier).

### Request Example
#### C#
```csharp
using System;
using System.ServiceModel;

namespace ConsoleApplication1
{
    using Packeta;
    class Program
    {
        static void Main(string[] args)
        {
            Packeta.PacketaClient gw = new PacketaClient();
            string apiPassword = "{{API_PASSWORD}}";

            PacketAttributes attrs = new PacketAttributes();
            attrs.number = "123456";
            attrs.name = "John";
            attrs.surname = "Doe";
            attrs.email = "example@packetatest.com";
            attrs.phone = "+420777123456";
            attrs.addressId = 79; //Praha 4, Pražského povstání, Na Pankráci 969/97
            attrs.cod = 145.55;
            attrs.value = 145.55;
            attrs.weight = 2;
            attrs.eshop = "MyEshop";

            PacketIdDetail packet;
            try
            {
                packet = gw.createPacket(apiPassword, attrs);
            }
            catch (FaultException<PacketAttributesFault> e) {
                // TODO: process error
            }
        }
    }
}
```

#### PHP
```php
<?php
$gw = new SoapClient("https://www.zasilkovna.cz/api/soap.wsdl");
$apiPassword = "1234567890abcdef1234567890abcdef";

try {
    $packet = $gw->createPacket($apiPassword, array(
        'number' => "123456",
        'name' => "John",
        'surname' => "Doe",
        'email' => "example@packetatest.com",
        'phone' => "+420777123456",
        'addressId' => 79,
        'cod' => 145.55,
        'value' => 145.55,
        'weight' => 2,
        'eshop' => "MyEshop"
    ));
} catch (SoapFault $e) {
    var_dump($e->detail); // property detail contains error info
}
```

### Response
#### Success Response
- Returns a PacketIdDetail object containing the packet ID.

#### Response Example
(No explicit response example provided in the source.)
```

--------------------------------

### Get courier label PNG with packetCourierLabelPng

Source: https://docs.packeta.com/docs/api-reference/api-methods

Returns a base64-encoded PNG label if the external carrier allows it (apiAllowed=true). Possible errors: PacketIdFault, NotSupportedFault, ExternalGatewayFault, InvalidCourierNumber. The PHP example sets the content type to image/png and echoes the PNG.

```PHP
<?php  
  
$packetId = '1234567890';  
$courierNumber = 'abcd1234567890';  
  
try {  
	$png = $client->packetCourierLabelPng($pw, $packetId, $courierNumber);  
	header('Content-Type: image/png');  
	echo $png;  
} catch (SoapFault $e) {  
	...  
}  

```

```XML
<packetCourierLabelPng>  
	<apiPassword>...</apiPassword>  
	<packetId>1234567890</packetId>  
	<courierNumber>abcd1234567890</courierNumber>  
</packetCourierLabelPng>  

```

--------------------------------

### Get courier label PDF with packetCourierLabelPdf

Source: https://docs.packeta.com/docs/api-reference/api-methods

Returns a base64-encoded PDF label if the external carrier allows it (apiAllowed=true). Possible errors: PacketIdFault, NotSupportedFault, ExternalGatewayFault, InvalidCourierNumber. The PHP example sets the content type to application/pdf and echoes the PDF.

```PHP
<?php  
  
$packetId = '1234567890';  
$courierNumber = 'abcd1234567890';  
  
try {  
	$pdf = $client->packetCourierLabelPdf($pw, $packetId, $courierNumber);  
	header('Content-Type: application/pdf');  
	echo $pdf;  
} catch (SoapFault $e) {  
	...  
}  

```

```XML
<packetCourierLabelPdf>  
	<apiPassword>...</apiPassword>  
	<packetId>1234567890</packetId>  
	<courierNumber>abcd1234567890</courierNumber>  
</packetCourierLabelPdf>  

```
Tokens:
Raw