> For the complete documentation index, see [llms.txt](https://developers.docstudio.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://developers.docstudio.com/guides/envelope-sending-options.md).

# Envelope Sending Options

This document contains alternative envelope-sending endpoints for share-code, Quick Send, public Quick Send, and One-time Send.

DocStudio provides several endpoints for sending envelopes in addition to the standard `POST /api/v1/envelope/send` flow. The correct endpoint depends on whether the envelope uses a reusable template, uploaded external documents, a public sending flow, or a one-time template.

### Business goals

The envelope-sending endpoints support the following business goals:

* **Send from a shared template.** Use a share code and verification code to create and send an envelope without referencing the template UUID directly.
* **Send external documents quickly.** Upload existing files and define recipients without constructing template and envelope XML.
* **Provide a public sending flow.** Allow a signer to send one external document through a verification-code-based request.
* **Use a template once.** Send an envelope from inline template and envelope XML when the template must not remain available for reuse.

### Choose a sending method

<table><thead><tr><th width="205.55560302734375">Endpoint</th><th>Use when</th><th>Key requirement</th></tr></thead><tbody><tr><td><code>POST /api/v1/envelope/send</code></td><td>Send from an existing reusable template</td><td>Template UUID and template version</td></tr><tr><td><code>POST /api/v1/envelope/send-by-share-code</code></td><td>Send from a shared template</td><td>Share code and verification code</td></tr><tr><td><code>POST /api/v1/envelope/quick-send</code></td><td>Send one or more external documents from a mailbox</td><td>API token and <code>Mailbox</code> header</td></tr><tr><td><code>POST /api/v1/envelope/public-quick-send</code></td><td>Publicly send one external document</td><td>Verification code and signer email</td></tr><tr><td><code>POST /api/v1/envelope/one-time-send</code></td><td>Send from inline template and envelope XML</td><td>Template is marked as deleted after use</td></tr></tbody></table>

Use the standard [Send Envelope](/api-reference/send-envelope.md) endpoint when the template must remain reusable. The sections below describe the alternative sending methods.

### Quick Send and Public Quick Send

<table><thead><tr><th width="138">Property</th><th width="290">Quick Send</th><th>Public Quick Send</th></tr></thead><tbody><tr><td>Authentication</td><td>API token and <code>Mailbox</code> header</td><td>Public verification-code flow</td></tr><tr><td>Files</td><td>One or more <code>files</code> parts</td><td>One <code>file</code> part</td></tr><tr><td>Recipient input</td><td><code>recipients</code> array</td><td>One <code>signer</code> email</td></tr><tr><td>Endpoint</td><td><code>/api/v1/envelope/quick-send</code></td><td><code>/api/v1/envelope/public-quick-send</code></td></tr></tbody></table>

### Send an envelope by share code

Use `POST /api/v1/envelope/send-by-share-code` when a template is made available through a share code. The request contains the share code, its verification code, and the envelope XML serialized as a JSON string.

See [XML payloads](/guides/xml-payloads.md) for guidance on serializing envelope XML as a JSON string.

**Request**

<table><thead><tr><th width="164.22216796875">Field</th><th width="85.666748046875">Type</th><th width="82.888916015625">Required</th><th>Description</th></tr></thead><tbody><tr><td><code>shareCode</code></td><td>string</td><td>Yes</td><td>Share code that identifies the shared template</td></tr><tr><td><code>verificationCode</code></td><td>string</td><td>Yes</td><td>Verification code for the shared-template flow</td></tr><tr><td><code>data</code></td><td>string</td><td>Yes</td><td>Envelope XML serialized as a JSON string</td></tr><tr><td><code>agreed</code></td><td>boolean</td><td>No</td><td>Indicates whether the required agreement was accepted</td></tr></tbody></table>

{% tabs %}
{% tab title="Node.js" %}

```javascript
const payload = {
  shareCode: "{shareCode}",
  verificationCode: "{verificationCode}",
  data: "{envelopeXml}",
  agreed: true
};

const response = await fetch(
  "https://api.docstudio.com/api/v1/envelope/send-by-share-code",
  {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      Accept: "application/json"
    },
    body: JSON.stringify(payload)
  }
);

const body = await response.text();

if (!response.ok) {
  throw new Error(
    `Request failed: ${response.status}\n${body}`
  );
}

console.log(body);
```

{% endtab %}

{% tab title="PHP" %}

```php
<?php

$payload = [
    "shareCode" => "{shareCode}",
    "verificationCode" => "{verificationCode}",
    "data" => "{envelopeXml}",
    "agreed" => true
];

$curl = curl_init(
    "https://api.docstudio.com/api/v1/envelope/send-by-share-code"
);

curl_setopt_array($curl, [
    CURLOPT_POST => true,
    CURLOPT_HTTPHEADER => [
        "Content-Type: application/json",
        "Accept: application/json"
    ],
    CURLOPT_POSTFIELDS => json_encode($payload),
    CURLOPT_RETURNTRANSFER => true
]);

$body = curl_exec($curl);

if ($body === false) {
    throw new RuntimeException(
        curl_error($curl)
    );
}

$status = curl_getinfo(
    $curl,
    CURLINFO_RESPONSE_CODE
);

curl_close($curl);

if ($status < 200 || $status >= 300) {
    throw new RuntimeException(
        "Request failed: {$status}\n{$body}"
    );
}

echo $body;
```

{% endtab %}

{% tab title="Python" %}

```python
import requests

response = requests.post(
    "https://api.docstudio.com/api/v1/envelope/send-by-share-code",
    headers={
        "Accept": "application/json",
    },
    json={
        "shareCode": "{shareCode}",
        "verificationCode": "{verificationCode}",
        "data": "{envelopeXml}",
        "agreed": True,
    },
    timeout=30,
)

response.raise_for_status()
print(response.json())
```

{% endtab %}

{% tab title="Ruby" %}

```ruby
require "json"
require "net/http"
require "uri"

uri = URI(
  "https://api.docstudio.com/api/v1/envelope/send-by-share-code"
)

payload = {
  shareCode: "{shareCode}",
  verificationCode: "{verificationCode}",
  data: "{envelopeXml}",
  agreed: true
}

request = Net::HTTP::Post.new(uri)
request["Content-Type"] = "application/json"
request["Accept"] = "application/json"
request.body = JSON.generate(payload)

response = Net::HTTP.start(
  uri.hostname,
  uri.port,
  use_ssl: true
) do |http|
  http.request(request)
end

unless response.is_a?(Net::HTTPSuccess)
  raise "Request failed: #{response.code}\n#{response.body}"
end

puts response.body
```

{% endtab %}

{% tab title="Go" %}

```go
package main

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

func main() {
	payload := map[string]any{
		"shareCode":       "{shareCode}",
		"verificationCode": "{verificationCode}",
		"data":            "{envelopeXml}",
		"agreed":          true,
	}

	requestBody, err := json.Marshal(payload)
	if err != nil {
		panic(err)
	}

	request, err := http.NewRequest(
		http.MethodPost,
		"https://api.docstudio.com/api/v1/envelope/send-by-share-code",
		bytes.NewReader(requestBody),
	)
	if err != nil {
		panic(err)
	}

	request.Header.Set(
		"Content-Type",
		"application/json",
	)
	request.Header.Set(
		"Accept",
		"application/json",
	)

	response, err := http.DefaultClient.Do(request)
	if err != nil {
		panic(err)
	}
	defer response.Body.Close()

	body, err := io.ReadAll(response.Body)
	if err != nil {
		panic(err)
	}

	if response.StatusCode < 200 ||
		response.StatusCode >= 300 {
		panic(fmt.Sprintf(
			"Request failed: %s\n%s",
			response.Status,
			body,
		))
	}

	fmt.Println(string(body))
}
```

{% endtab %}

{% tab title="Java" %}

```java
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Main {
  public static void main(String[] args) throws Exception {
    String payload = """
        {
          "shareCode": "{shareCode}",
          "verificationCode": "{verificationCode}",
          "data": "{envelopeXml}",
          "agreed": true
        }
        """;

    HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create(
            "https://api.docstudio.com/api/v1/envelope/send-by-share-code"
        ))
        .header(
            "Content-Type",
            "application/json"
        )
        .header(
            "Accept",
            "application/json"
        )
        .POST(
            HttpRequest.BodyPublishers.ofString(payload)
        )
        .build();

    HttpResponse<String> response =
        HttpClient.newHttpClient().send(
            request,
            HttpResponse.BodyHandlers.ofString()
        );

    if (response.statusCode() < 200 ||
        response.statusCode() >= 300) {
      throw new RuntimeException(
          "Request failed: " +
          response.statusCode() +
          "\n" +
          response.body()
      );
    }

    System.out.println(response.body());
  }
}
```

{% endtab %}

{% tab title=".NET" %}

```csharp
using System.Net.Http.Json;

using var client = new HttpClient();

client.DefaultRequestHeaders.Add(
    "Accept",
    "application/json"
);

var payload = new
{
    shareCode = "{shareCode}",
    verificationCode = "{verificationCode}",
    data = "{envelopeXml}",
    agreed = true
};

using var response = await client.PostAsJsonAsync(
    "https://api.docstudio.com/api/v1/envelope/send-by-share-code",
    payload
);

var body =
    await response.Content.ReadAsStringAsync();

if (!response.IsSuccessStatusCode)
{
    throw new HttpRequestException(
        $"Request failed: " +
        $"{(int)response.StatusCode}\n{body}"
    );
}

Console.WriteLine(body);
```

{% endtab %}

{% tab title="cURL" %}

```bash
curl --request POST \
  --url 'https://api.docstudio.com/api/v1/envelope/send-by-share-code' \
  --header 'Content-Type: application/json' \
  --header 'Accept: application/json' \
  --data '{
    "shareCode": "{shareCode}",
    "verificationCode": "{verificationCode}",
    "data": "{envelopeXml}",
    "agreed": true
  }'
```

{% endtab %}
{% endtabs %}

**Response**

A successful request returns `201 Created`. Save the returned identifiers and token because they identify the created envelope and its mailbox context.

```json
{
  "token": "{token}",
  "envelopeUuid": "{envelopeUuid}",
  "mailboxUuid": "{mailboxUuid}"
}
```

<table><thead><tr><th width="256.888916015625">Field</th><th width="80.888916015625">Type</th><th>Description</th></tr></thead><tbody><tr><td><code>token</code></td><td>UUID</td><td>Token returned for the share-code sending flow</td></tr><tr><td><code>envelopeUuid</code></td><td>UUID</td><td>UUID of the created envelope</td></tr><tr><td><code>mailboxUuid</code></td><td>UUID</td><td>UUID of the mailbox associated with the envelope</td></tr></tbody></table>

### Quick Send external documents

Use `POST /api/v1/envelope/quick-send` to send existing files without preparing template XML. The request uses `multipart/form-data` and contains one or more files together with a JSON `data` part.

The operation requires an API token and the sender mailbox UUID in the `Mailbox` header.

**Headers**

| Header          | Required | Description                |
| --------------- | -------- | -------------------------- |
| `Authorization` | Yes      | Bearer authorization token |
| `Mailbox`       | Yes      | UUID of the sender mailbox |
| `Accept`        | No       | `application/json`         |

**Request parts**

<table><thead><tr><th width="75.66668701171875">Part</th><th width="171.4444580078125">Type</th><th width="106.111083984375">Required</th><th>Description</th></tr></thead><tbody><tr><td><code>files</code></td><td>array of binary files</td><td>Yes</td><td>External documents included in the envelope</td></tr><tr><td><code>data</code></td><td>JSON object</td><td>Yes</td><td><code>QuickSendDTO</code> sent as a blob with <code>Content-Type: application/json</code></td></tr></tbody></table>

The `data` object supports the following properties:

<table><thead><tr><th width="189.4444580078125">Property</th><th width="81.22216796875">Type</th><th width="106.111083984375">Required</th><th>Description</th></tr></thead><tbody><tr><td><code>subject</code></td><td>string</td><td>Yes</td><td>Envelope subject</td></tr><tr><td><code>message</code></td><td>string</td><td>No</td><td>Message displayed to recipients</td></tr><tr><td><code>recipients</code></td><td>array</td><td>No</td><td>Recipients and their required actions</td></tr><tr><td><code>signatureAlgorithm</code></td><td>string</td><td>No</td><td>Signature algorithm: <code>DSTU4145</code> or <code>ECDSA_RSA</code></td></tr><tr><td><code>signatureContainer</code></td><td>string</td><td>No</td><td>Signature container: <code>P7S</code>, <code>ASICE</code>, or <code>P7S_ENVELOPED</code></td></tr><tr><td><code>recipientExperience</code></td><td>object</td><td>No</td><td>Language, locale, and time-zone settings for recipients</td></tr></tbody></table>

Each object in `recipients` supports these properties:

<table><thead><tr><th width="139">Property</th><th width="88.2222900390625">Type</th><th width="106.111083984375">Required</th><th>Description</th></tr></thead><tbody><tr><td><code>recipient</code></td><td>string</td><td>Yes</td><td>Recipient identifier</td></tr><tr><td><code>approver</code></td><td>boolean</td><td>No</td><td>Requires the recipient to approve the document</td></tr><tr><td><code>signer</code></td><td>boolean</td><td>No</td><td>Requires the recipient to sign the document</td></tr><tr><td><code>eInkSignature</code></td><td>boolean</td><td>No</td><td>Enables an electronic handwritten signature action</td></tr></tbody></table>

The `recipient` value identifies the recipient. The example uses an email address. Set the recipient action fields required by the workflow.

When `recipientExperience` is included, provide its required properties:

| Property   | Example       | Description                  |
| ---------- | ------------- | ---------------------------- |
| `language` | `en`          | Recipient interface language |
| `locale`   | `en-US`       | Recipient locale             |
| `timezone` | `Europe/Kyiv` | Recipient time zone          |

**Practical example: Send a contract for signature**

The following request uploads a PDF contract and sends it to a signer:

{% tabs %}
{% tab title="Node.js" %}

```javascript
import { openAsBlob } from "node:fs";

const payload = {
  subject: "Contract for signature",
  message: "Please review and sign the attached contract.",
  recipients: [
    {
      recipient: "signer@example.com",
      approver: false,
      signer: true,
      eInkSignature: false
    }
  ],
  signatureAlgorithm: "ECDSA_RSA",
  signatureContainer: "P7S",
  recipientExperience: {
    language: "en",
    locale: "en-US",
    timezone: "Europe/Kyiv"
  }
};

const form = new FormData();

form.append(
  "files",
  await openAsBlob("contract.pdf"),
  "contract.pdf"
);

form.append(
  "data",
  new Blob(
    [JSON.stringify(payload)],
    { type: "application/json" }
  )
);

const response = await fetch(
  "https://api.docstudio.com/api/v1/envelope/quick-send",
  {
    method: "POST",
    headers: {
      Authorization: "Bearer {token}",
      Mailbox: "{mailboxUuid}",
      Accept: "application/json"
    },
    body: form
  }
);

const body = await response.text();

if (!response.ok) {
  throw new Error(
    `Request failed: ${response.status}\n${body}`
  );
}

console.log(body);
```

{% endtab %}

{% tab title="PHP" %}

```php
<?php

$payload = [
    "subject" => "Contract for signature",
    "message" => "Please review and sign the attached contract.",
    "recipients" => [
        [
            "recipient" => "signer@example.com",
            "approver" => false,
            "signer" => true,
            "eInkSignature" => false
        ]
    ],
    "signatureAlgorithm" => "ECDSA_RSA",
    "signatureContainer" => "P7S",
    "recipientExperience" => [
        "language" => "en",
        "locale" => "en-US",
        "timezone" => "Europe/Kyiv"
    ]
];

$form = [
    "files" => new CURLFile(
        "contract.pdf",
        "application/pdf",
        "contract.pdf"
    ),
    "data" => new CURLStringFile(
        json_encode($payload),
        "data.json",
        "application/json"
    )
];

$curl = curl_init(
    "https://api.docstudio.com/api/v1/envelope/quick-send"
);

curl_setopt_array($curl, [
    CURLOPT_POST => true,
    CURLOPT_HTTPHEADER => [
        "Authorization: Bearer {token}",
        "Mailbox: {mailboxUuid}",
        "Accept: application/json"
    ],
    CURLOPT_POSTFIELDS => $form,
    CURLOPT_RETURNTRANSFER => true
]);

$body = curl_exec($curl);

if ($body === false) {
    throw new RuntimeException(
        curl_error($curl)
    );
}

$status = curl_getinfo(
    $curl,
    CURLINFO_RESPONSE_CODE
);

curl_close($curl);

if ($status < 200 || $status >= 300) {
    throw new RuntimeException(
        "Request failed: {$status}\n{$body}"
    );
}

echo $body;
```

{% endtab %}

{% tab title="Python" %}

```python
import json

import requests

payload = {
    "subject": "Contract for signature",
    "message": "Please review and sign the attached contract.",
    "recipients": [
        {
            "recipient": "signer@example.com",
            "approver": False,
            "signer": True,
            "eInkSignature": False,
        }
    ],
    "signatureAlgorithm": "ECDSA_RSA",
    "signatureContainer": "P7S",
    "recipientExperience": {
        "language": "en",
        "locale": "en-US",
        "timezone": "Europe/Kyiv",
    },
}

with open("contract.pdf", "rb") as document:
    response = requests.post(
        "https://api.docstudio.com/api/v1/envelope/quick-send",
        headers={
            "Authorization": "Bearer {token}",
            "Mailbox": "{mailboxUuid}",
            "Accept": "application/json",
        },
        files={
            "files": (
                "contract.pdf",
                document,
                "application/pdf",
            ),
            "data": (
                None,
                json.dumps(payload),
                "application/json",
            ),
        },
        timeout=30,
    )

response.raise_for_status()
print(response.json())
```

{% endtab %}

{% tab title="Ruby" %}

```ruby
require "json"
require "net/http"
require "uri"

uri = URI(
  "https://api.docstudio.com/api/v1/envelope/quick-send"
)

payload = {
  subject: "Contract for signature",
  message: "Please review and sign the attached contract.",
  recipients: [
    {
      recipient: "signer@example.com",
      approver: false,
      signer: true,
      eInkSignature: false
    }
  ],
  signatureAlgorithm: "ECDSA_RSA",
  signatureContainer: "P7S",
  recipientExperience: {
    language: "en",
    locale: "en-US",
    timezone: "Europe/Kyiv"
  }
}

request = Net::HTTP::Post.new(uri)
request["Authorization"] = "Bearer {token}"
request["Mailbox"] = "{mailboxUuid}"
request["Accept"] = "application/json"

file = File.open("contract.pdf", "rb")

request.set_form(
  [
    [
      "files",
      file,
      {
        filename: "contract.pdf",
        content_type: "application/pdf"
      }
    ],
    [
      "data",
      JSON.generate(payload),
      {
        content_type: "application/json"
      }
    ]
  ],
  "multipart/form-data"
)

response = Net::HTTP.start(
  uri.hostname,
  uri.port,
  use_ssl: true
) do |http|
  http.request(request)
end

file.close

unless response.is_a?(Net::HTTPSuccess)
  raise "Request failed: #{response.code}\n#{response.body}"
end

puts response.body
```

{% endtab %}

{% tab title="Go" %}

```go
package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"mime/multipart"
	"net/http"
	"net/textproto"
	"os"
)

func main() {
	payload := map[string]any{
		"subject": "Contract for signature",
		"message": "Please review and sign the attached contract.",
		"recipients": []map[string]any{
			{
				"recipient":      "signer@example.com",
				"approver":       false,
				"signer":         true,
				"eInkSignature": false,
			},
		},
		"signatureAlgorithm": "ECDSA_RSA",
		"signatureContainer": "P7S",
		"recipientExperience": map[string]string{
			"language": "en",
			"locale":   "en-US",
			"timezone": "Europe/Kyiv",
		},
	}

	var requestBody bytes.Buffer
	writer := multipart.NewWriter(&requestBody)

	file, err := os.Open("contract.pdf")
	if err != nil {
		panic(err)
	}
	defer file.Close()

	filePart, err := writer.CreateFormFile(
		"files",
		"contract.pdf",
	)
	if err != nil {
		panic(err)
	}

	if _, err := io.Copy(filePart, file); err != nil {
		panic(err)
	}

	jsonData, err := json.Marshal(payload)
	if err != nil {
		panic(err)
	}

	headers := make(textproto.MIMEHeader)
	headers.Set(
		"Content-Disposition",
		`form-data; name="data"`,
	)
	headers.Set(
		"Content-Type",
		"application/json",
	)

	dataPart, err := writer.CreatePart(headers)
	if err != nil {
		panic(err)
	}

	if _, err := dataPart.Write(jsonData); err != nil {
		panic(err)
	}

	if err := writer.Close(); err != nil {
		panic(err)
	}

	request, err := http.NewRequest(
		http.MethodPost,
		"https://api.docstudio.com/api/v1/envelope/quick-send",
		&requestBody,
	)
	if err != nil {
		panic(err)
	}

	request.Header.Set(
		"Authorization",
		"Bearer {token}",
	)
	request.Header.Set(
		"Mailbox",
		"{mailboxUuid}",
	)
	request.Header.Set(
		"Accept",
		"application/json",
	)
	request.Header.Set(
		"Content-Type",
		writer.FormDataContentType(),
	)

	response, err := http.DefaultClient.Do(request)
	if err != nil {
		panic(err)
	}
	defer response.Body.Close()

	body, err := io.ReadAll(response.Body)
	if err != nil {
		panic(err)
	}

	if response.StatusCode < 200 ||
		response.StatusCode >= 300 {
		panic(fmt.Sprintf(
			"Request failed: %s\n%s",
			response.Status,
			body,
		))
	}

	fmt.Println(string(body))
}
```

{% endtab %}

{% tab title="Java" %}

```java
import java.io.ByteArrayOutputStream;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.UUID;

public class Main {
  public static void main(String[] args) throws Exception {
    String boundary =
        "DocStudioBoundary" +
        UUID.randomUUID();

    String payload = """
        {
          "subject": "Contract for signature",
          "message": "Please review and sign the attached contract.",
          "recipients": [
            {
              "recipient": "signer@example.com",
              "approver": false,
              "signer": true,
              "eInkSignature": false
            }
          ],
          "signatureAlgorithm": "ECDSA_RSA",
          "signatureContainer": "P7S",
          "recipientExperience": {
            "language": "en",
            "locale": "en-US",
            "timezone": "Europe/Kyiv"
          }
        }
        """;

    ByteArrayOutputStream body =
        new ByteArrayOutputStream();

    writeText(body, "--" + boundary + "\r\n");
    writeText(
        body,
        "Content-Disposition: form-data; " +
        "name=\"files\"; " +
        "filename=\"contract.pdf\"\r\n"
    );
    writeText(
        body,
        "Content-Type: application/pdf\r\n\r\n"
    );
    body.write(
        Files.readAllBytes(
            Path.of("contract.pdf")
        )
    );
    writeText(body, "\r\n");

    writeText(body, "--" + boundary + "\r\n");
    writeText(
        body,
        "Content-Disposition: form-data; " +
        "name=\"data\"\r\n"
    );
    writeText(
        body,
        "Content-Type: application/json\r\n\r\n"
    );
    writeText(body, payload);
    writeText(body, "\r\n");

    writeText(
        body,
        "--" + boundary + "--\r\n"
    );

    HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create(
            "https://api.docstudio.com/api/v1/envelope/quick-send"
        ))
        .header(
            "Authorization",
            "Bearer {token}"
        )
        .header(
            "Mailbox",
            "{mailboxUuid}"
        )
        .header(
            "Accept",
            "application/json"
        )
        .header(
            "Content-Type",
            "multipart/form-data; boundary=" + boundary
        )
        .POST(
            HttpRequest.BodyPublishers.ofByteArray(
                body.toByteArray()
            )
        )
        .build();

    HttpResponse<String> response =
        HttpClient.newHttpClient().send(
            request,
            HttpResponse.BodyHandlers.ofString()
        );

    if (response.statusCode() < 200 ||
        response.statusCode() >= 300) {
      throw new RuntimeException(
          "Request failed: " +
          response.statusCode() +
          "\n" +
          response.body()
      );
    }

    System.out.println(response.body());
  }

  private static void writeText(
      ByteArrayOutputStream output,
      String value
  ) throws Exception {
    output.write(
        value.getBytes(StandardCharsets.UTF_8)
    );
  }
}
```

{% endtab %}

{% tab title=".NET" %}

```csharp
using System.Net.Http.Headers;
using System.Text;

using var client = new HttpClient();

client.DefaultRequestHeaders.Authorization =
    new AuthenticationHeaderValue(
        "Bearer",
        "{token}"
    );

client.DefaultRequestHeaders.Add(
    "Mailbox",
    "{mailboxUuid}"
);

client.DefaultRequestHeaders.Add(
    "Accept",
    "application/json"
);

var payload = """
{
  "subject": "Contract for signature",
  "message": "Please review and sign the attached contract.",
  "recipients": [
    {
      "recipient": "signer@example.com",
      "approver": false,
      "signer": true,
      "eInkSignature": false
    }
  ],
  "signatureAlgorithm": "ECDSA_RSA",
  "signatureContainer": "P7S",
  "recipientExperience": {
    "language": "en",
    "locale": "en-US",
    "timezone": "Europe/Kyiv"
  }
}
""";

using var form =
    new MultipartFormDataContent();

using var fileContent =
    new StreamContent(
        File.OpenRead("contract.pdf")
    );

fileContent.Headers.ContentType =
    new MediaTypeHeaderValue(
        "application/pdf"
    );

form.Add(
    fileContent,
    "files",
    "contract.pdf"
);

using var dataContent = new StringContent(
    payload,
    Encoding.UTF8,
    "application/json"
);

form.Add(
    dataContent,
    "data"
);

using var response = await client.PostAsync(
    "https://api.docstudio.com/api/v1/envelope/quick-send",
    form
);

var body =
    await response.Content.ReadAsStringAsync();

if (!response.IsSuccessStatusCode)
{
    throw new HttpRequestException(
        $"Request failed: " +
        $"{(int)response.StatusCode}\n{body}"
    );
}

Console.WriteLine(body);
```

{% endtab %}

{% tab title="cURL" %}

```bash
curl --request POST \
  --url 'https://api.docstudio.com/api/v1/envelope/quick-send' \
  --header 'Authorization: Bearer {token}' \
  --header 'Mailbox: {mailboxUuid}' \
  --header 'Accept: application/json' \
  --form 'files=@contract.pdf;type=application/pdf' \
  --form 'data={
    "subject": "Contract for signature",
    "message": "Please review and sign the attached contract.",
    "recipients": [
      {
        "recipient": "signer@example.com",
        "approver": false,
        "signer": true,
        "eInkSignature": false
      }
    ],
    "signatureAlgorithm": "ECDSA_RSA",
    "signatureContainer": "P7S",
    "recipientExperience": {
      "language": "en",
      "locale": "en-US",
      "timezone": "Europe/Kyiv"
    }
  };type=application/json'
```

{% endtab %}
{% endtabs %}

A successful request returns `201 Created` with the envelope UUID:

```json
{
  "uuid": "{envelopeUuid}"
}
```

### Public Quick Send

Use `POST /api/v1/envelope/public-quick-send` to send one external document through a public verification-code-based flow. Unlike Quick Send, this endpoint accepts one `file` and does not define a `Mailbox` header.

The request uses `multipart/form-data`. The `data` part must be sent as a JSON blob with `Content-Type: application/json`.

{% hint style="warning" %}
Treat verification codes as sensitive values. Do not include them in URLs, client-side logs, or application logs.
{% endhint %}

**Request parts**

<table><thead><tr><th width="76.77777099609375">Part</th><th width="149.22222900390625">Type</th><th width="106.666748046875">Required</th><th>Description</th></tr></thead><tbody><tr><td><code>file</code></td><td>binary file</td><td>Yes</td><td>External document included in the envelope</td></tr><tr><td><code>data</code></td><td>JSON object</td><td>Yes</td><td>Public sending configuration</td></tr></tbody></table>

The `data` object contains the following properties:

<table><thead><tr><th width="164.22222900390625">Property</th><th width="87">Type</th><th width="106.77783203125">Required</th><th>Description</th></tr></thead><tbody><tr><td><code>verificationCode</code></td><td>string</td><td>Yes</td><td>Verification code for the public sending flow</td></tr><tr><td><code>agreed</code></td><td>boolean</td><td>No</td><td>Indicates whether the required agreement was accepted</td></tr><tr><td><code>signer</code></td><td>email</td><td>Yes</td><td>Email address of the signer</td></tr></tbody></table>

**Practical example: Publicly send one document**

{% tabs %}
{% tab title="Node.js" %}

```javascript
import { openAsBlob } from "node:fs";

const payload = {
  verificationCode: "{verificationCode}",
  agreed: true,
  signer: "signer@example.com"
};

const form = new FormData();

form.append(
  "file",
  await openAsBlob("agreement.pdf"),
  "agreement.pdf"
);

form.append(
  "data",
  new Blob(
    [JSON.stringify(payload)],
    { type: "application/json" }
  )
);

const response = await fetch(
  "https://api.docstudio.com/api/v1/envelope/public-quick-send",
  {
    method: "POST",
    headers: {
      Accept: "application/json"
    },
    body: form
  }
);

const body = await response.text();

if (!response.ok) {
  throw new Error(
    `Request failed: ${response.status}\n${body}`
  );
}

console.log(body);
```

{% endtab %}

{% tab title="PHP" %}

```php
<?php

$payload = [
    "verificationCode" => "{verificationCode}",
    "agreed" => true,
    "signer" => "signer@example.com"
];

$form = [
    "file" => new CURLFile(
        "agreement.pdf",
        "application/pdf",
        "agreement.pdf"
    ),
    "data" => new CURLStringFile(
        json_encode($payload),
        "data.json",
        "application/json"
    )
];

$curl = curl_init(
    "https://api.docstudio.com/api/v1/envelope/public-quick-send"
);

curl_setopt_array($curl, [
    CURLOPT_POST => true,
    CURLOPT_HTTPHEADER => [
        "Accept: application/json"
    ],
    CURLOPT_POSTFIELDS => $form,
    CURLOPT_RETURNTRANSFER => true
]);

$body = curl_exec($curl);

if ($body === false) {
    throw new RuntimeException(
        curl_error($curl)
    );
}

$status = curl_getinfo(
    $curl,
    CURLINFO_RESPONSE_CODE
);

curl_close($curl);

if ($status < 200 || $status >= 300) {
    throw new RuntimeException(
        "Request failed: {$status}\n{$body}"
    );
}

echo $body;
```

{% endtab %}

{% tab title="Python" %}

```python
import json

import requests

payload = {
    "verificationCode": "{verificationCode}",
    "agreed": True,
    "signer": "signer@example.com",
}

with open("agreement.pdf", "rb") as document:
    response = requests.post(
        "https://api.docstudio.com/api/v1/envelope/public-quick-send",
        headers={
            "Accept": "application/json",
        },
        files={
            "file": (
                "agreement.pdf",
                document,
                "application/pdf",
            ),
            "data": (
                None,
                json.dumps(payload),
                "application/json",
            ),
        },
        timeout=30,
    )

response.raise_for_status()
print(response.json())
```

{% endtab %}

{% tab title="Ruby" %}

```ruby
require "json"
require "net/http"
require "uri"

uri = URI(
  "https://api.docstudio.com/api/v1/envelope/public-quick-send"
)

payload = {
  verificationCode: "{verificationCode}",
  agreed: true,
  signer: "signer@example.com"
}

request = Net::HTTP::Post.new(uri)
request["Accept"] = "application/json"

file = File.open("agreement.pdf", "rb")

request.set_form(
  [
    [
      "file",
      file,
      {
        filename: "agreement.pdf",
        content_type: "application/pdf"
      }
    ],
    [
      "data",
      JSON.generate(payload),
      {
        content_type: "application/json"
      }
    ]
  ],
  "multipart/form-data"
)

response = Net::HTTP.start(
  uri.hostname,
  uri.port,
  use_ssl: true
) do |http|
  http.request(request)
end

file.close

unless response.is_a?(Net::HTTPSuccess)
  raise "Request failed: #{response.code}\n#{response.body}"
end

puts response.body
```

{% endtab %}

{% tab title="Go" %}

```go
package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"mime/multipart"
	"net/http"
	"net/textproto"
	"os"
)

func main() {
	payload := map[string]any{
		"verificationCode": "{verificationCode}",
		"agreed":           true,
		"signer":           "signer@example.com",
	}

	var requestBody bytes.Buffer
	writer := multipart.NewWriter(&requestBody)

	file, err := os.Open("agreement.pdf")
	if err != nil {
		panic(err)
	}
	defer file.Close()

	filePart, err := writer.CreateFormFile(
		"file",
		"agreement.pdf",
	)
	if err != nil {
		panic(err)
	}

	if _, err := io.Copy(filePart, file); err != nil {
		panic(err)
	}

	jsonData, err := json.Marshal(payload)
	if err != nil {
		panic(err)
	}

	headers := make(textproto.MIMEHeader)
	headers.Set(
		"Content-Disposition",
		`form-data; name="data"`,
	)
	headers.Set(
		"Content-Type",
		"application/json",
	)

	dataPart, err := writer.CreatePart(headers)
	if err != nil {
		panic(err)
	}

	if _, err := dataPart.Write(jsonData); err != nil {
		panic(err)
	}

	if err := writer.Close(); err != nil {
		panic(err)
	}

	request, err := http.NewRequest(
		http.MethodPost,
		"https://api.docstudio.com/api/v1/envelope/public-quick-send",
		&requestBody,
	)
	if err != nil {
		panic(err)
	}

	request.Header.Set(
		"Accept",
		"application/json",
	)
	request.Header.Set(
		"Content-Type",
		writer.FormDataContentType(),
	)

	response, err := http.DefaultClient.Do(request)
	if err != nil {
		panic(err)
	}
	defer response.Body.Close()

	body, err := io.ReadAll(response.Body)
	if err != nil {
		panic(err)
	}

	if response.StatusCode < 200 ||
		response.StatusCode >= 300 {
		panic(fmt.Sprintf(
			"Request failed: %s\n%s",
			response.Status,
			body,
		))
	}

	fmt.Println(string(body))
}
```

{% endtab %}

{% tab title="Java" %}

```java
import java.io.ByteArrayOutputStream;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.UUID;

public class Main {
  public static void main(String[] args) throws Exception {
    String boundary =
        "DocStudioBoundary" +
        UUID.randomUUID();

    String payload = """
        {
          "verificationCode": "{verificationCode}",
          "agreed": true,
          "signer": "signer@example.com"
        }
        """;

    ByteArrayOutputStream body =
        new ByteArrayOutputStream();

    writeText(body, "--" + boundary + "\r\n");
    writeText(
        body,
        "Content-Disposition: form-data; " +
        "name=\"file\"; " +
        "filename=\"agreement.pdf\"\r\n"
    );
    writeText(
        body,
        "Content-Type: application/pdf\r\n\r\n"
    );
    body.write(
        Files.readAllBytes(
            Path.of("agreement.pdf")
        )
    );
    writeText(body, "\r\n");

    writeText(body, "--" + boundary + "\r\n");
    writeText(
        body,
        "Content-Disposition: form-data; " +
        "name=\"data\"\r\n"
    );
    writeText(
        body,
        "Content-Type: application/json\r\n\r\n"
    );
    writeText(body, payload);
    writeText(body, "\r\n");

    writeText(
        body,
        "--" + boundary + "--\r\n"
    );

    HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create(
            "https://api.docstudio.com/api/v1/envelope/public-quick-send"
        ))
        .header(
            "Accept",
            "application/json"
        )
        .header(
            "Content-Type",
            "multipart/form-data; boundary=" + boundary
        )
        .POST(
            HttpRequest.BodyPublishers.ofByteArray(
                body.toByteArray()
            )
        )
        .build();

    HttpResponse<String> response =
        HttpClient.newHttpClient().send(
            request,
            HttpResponse.BodyHandlers.ofString()
        );

    if (response.statusCode() < 200 ||
        response.statusCode() >= 300) {
      throw new RuntimeException(
          "Request failed: " +
          response.statusCode() +
          "\n" +
          response.body()
      );
    }

    System.out.println(response.body());
  }

  private static void writeText(
      ByteArrayOutputStream output,
      String value
  ) throws Exception {
    output.write(
        value.getBytes(StandardCharsets.UTF_8)
    );
  }
}
```

{% endtab %}

{% tab title=".NET" %}

```csharp
using System.Net.Http.Headers;
using System.Text;

using var client = new HttpClient();

client.DefaultRequestHeaders.Add(
    "Accept",
    "application/json"
);

var payload = """
{
  "verificationCode": "{verificationCode}",
  "agreed": true,
  "signer": "signer@example.com"
}
""";

using var form =
    new MultipartFormDataContent();

using var fileContent =
    new StreamContent(
        File.OpenRead("agreement.pdf")
    );

fileContent.Headers.ContentType =
    new MediaTypeHeaderValue(
        "application/pdf"
    );

form.Add(
    fileContent,
    "file",
    "agreement.pdf"
);

using var dataContent = new StringContent(
    payload,
    Encoding.UTF8,
    "application/json"
);

form.Add(
    dataContent,
    "data"
);

using var response = await client.PostAsync(
    "https://api.docstudio.com/api/v1/envelope/public-quick-send",
    form
);

var body =
    await response.Content.ReadAsStringAsync();

if (!response.IsSuccessStatusCode)
{
    throw new HttpRequestException(
        $"Request failed: " +
        $"{(int)response.StatusCode}\n{body}"
    );
}

Console.WriteLine(body);
```

{% endtab %}

{% tab title="cURL" %}

```bash
curl --request POST \
  --url 'https://api.docstudio.com/api/v1/envelope/public-quick-send' \
  --header 'Accept: application/json' \
  --form 'file=@agreement.pdf;type=application/pdf' \
  --form 'data={
    "verificationCode": "{verificationCode}",
    "agreed": true,
    "signer": "signer@example.com"
  };type=application/json'
```

{% endtab %}
{% endtabs %}

A successful request returns `201 Created`. The response uses `id` as the envelope identifier:

```json
{
  "id": "{envelopeUuid}"
}
```

Use [Send Envelope](/api-reference/send-envelope.md) when the document flow requires a reusable template.

{% hint style="info" %}
Quick Send returns the envelope identifier in `uuid`. Public Quick Send returns it in `id`.
{% endhint %}

### One-time Send

Use `POST /api/v1/envelope/one-time-send` when the integration provides both the template XML and envelope XML in the request. The template is used for this sending operation and is then marked as deleted.

{% hint style="warning" %}
Do not use this endpoint when the template must remain available for future envelopes. Use [Send Envelope](/api-reference/send-envelope.md) with a reusable template instead.
{% endhint %}

**Headers**

| Header          | Required | Description                |
| --------------- | -------- | -------------------------- |
| `Authorization` | Yes      | Bearer authorization token |
| `Content-Type`  | Yes      | `application/json`         |
| `Mailbox`       | Yes      | UUID of the sender mailbox |

**Request**

<table><thead><tr><th width="180.55548095703125">Field</th><th width="81.22216796875">Type</th><th width="108">Required</th><th>Description</th></tr></thead><tbody><tr><td><code>templateXml</code></td><td>string</td><td>Yes</td><td>Template XML serialized as a JSON string</td></tr><tr><td><code>envelopeXml</code></td><td>string</td><td>Yes</td><td>Envelope XML serialized as a JSON string</td></tr><tr><td><code>signatureAlgorithm</code></td><td>string</td><td>No</td><td>Signature algorithm: <code>DSTU4145</code> or <code>ECDSA_RSA</code></td></tr><tr><td><code>signatureContainer</code></td><td>string</td><td>No</td><td>Signature container: <code>P7S</code>, <code>ASICE</code>, or <code>P7S_ENVELOPED</code></td></tr></tbody></table>

{% tabs %}
{% tab title="Node.js" %}

```javascript
const payload = {
  templateXml: "{templateXml}",
  envelopeXml: "{envelopeXml}",
  signatureAlgorithm: "ECDSA_RSA",
  signatureContainer: "P7S"
};

const response = await fetch(
  "https://api.docstudio.com/api/v1/envelope/one-time-send",
  {
    method: "POST",
    headers: {
      Authorization: "Bearer {token}",
      Mailbox: "{mailboxUuid}",
      "Content-Type": "application/json",
      Accept: "application/json"
    },
    body: JSON.stringify(payload)
  }
);

const body = await response.text();

if (!response.ok) {
  throw new Error(
    `Request failed: ${response.status}\n${body}`
  );
}

console.log(body);
```

{% endtab %}

{% tab title="PHP" %}

```php
<?php

$payload = [
    "templateXml" => "{templateXml}",
    "envelopeXml" => "{envelopeXml}",
    "signatureAlgorithm" => "ECDSA_RSA",
    "signatureContainer" => "P7S"
];

$curl = curl_init(
    "https://api.docstudio.com/api/v1/envelope/one-time-send"
);

curl_setopt_array($curl, [
    CURLOPT_POST => true,
    CURLOPT_HTTPHEADER => [
        "Authorization: Bearer {token}",
        "Mailbox: {mailboxUuid}",
        "Content-Type: application/json",
        "Accept: application/json"
    ],
    CURLOPT_POSTFIELDS => json_encode($payload),
    CURLOPT_RETURNTRANSFER => true
]);

$body = curl_exec($curl);

if ($body === false) {
    throw new RuntimeException(
        curl_error($curl)
    );
}

$status = curl_getinfo(
    $curl,
    CURLINFO_RESPONSE_CODE
);

curl_close($curl);

if ($status < 200 || $status >= 300) {
    throw new RuntimeException(
        "Request failed: {$status}\n{$body}"
    );
}

echo $body;
```

{% endtab %}

{% tab title="Python" %}

```python
import requests

response = requests.post(
    "https://api.docstudio.com/api/v1/envelope/one-time-send",
    headers={
        "Authorization": "Bearer {token}",
        "Mailbox": "{mailboxUuid}",
        "Accept": "application/json",
    },
    json={
        "templateXml": "{templateXml}",
        "envelopeXml": "{envelopeXml}",
        "signatureAlgorithm": "ECDSA_RSA",
        "signatureContainer": "P7S",
    },
    timeout=30,
)

response.raise_for_status()
print(response.json())
```

{% endtab %}

{% tab title="Ruby" %}

```ruby
require "json"
require "net/http"
require "uri"

uri = URI(
  "https://api.docstudio.com/api/v1/envelope/one-time-send"
)

payload = {
  templateXml: "{templateXml}",
  envelopeXml: "{envelopeXml}",
  signatureAlgorithm: "ECDSA_RSA",
  signatureContainer: "P7S"
}

request = Net::HTTP::Post.new(uri)
request["Authorization"] = "Bearer {token}"
request["Mailbox"] = "{mailboxUuid}"
request["Content-Type"] = "application/json"
request["Accept"] = "application/json"
request.body = JSON.generate(payload)

response = Net::HTTP.start(
  uri.hostname,
  uri.port,
  use_ssl: true
) do |http|
  http.request(request)
end

unless response.is_a?(Net::HTTPSuccess)
  raise "Request failed: #{response.code}\n#{response.body}"
end

puts response.body
```

{% endtab %}

{% tab title="Go" %}

```go
package main

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

func main() {
	payload := map[string]string{
		"templateXml":        "{templateXml}",
		"envelopeXml":        "{envelopeXml}",
		"signatureAlgorithm": "ECDSA_RSA",
		"signatureContainer": "P7S",
	}

	requestBody, err := json.Marshal(payload)
	if err != nil {
		panic(err)
	}

	request, err := http.NewRequest(
		http.MethodPost,
		"https://api.docstudio.com/api/v1/envelope/one-time-send",
		bytes.NewReader(requestBody),
	)
	if err != nil {
		panic(err)
	}

	request.Header.Set(
		"Authorization",
		"Bearer {token}",
	)
	request.Header.Set(
		"Mailbox",
		"{mailboxUuid}",
	)
	request.Header.Set(
		"Content-Type",
		"application/json",
	)
	request.Header.Set(
		"Accept",
		"application/json",
	)

	response, err := http.DefaultClient.Do(request)
	if err != nil {
		panic(err)
	}
	defer response.Body.Close()

	body, err := io.ReadAll(response.Body)
	if err != nil {
		panic(err)
	}

	if response.StatusCode < 200 ||
		response.StatusCode >= 300 {
		panic(fmt.Sprintf(
			"Request failed: %s\n%s",
			response.Status,
			body,
		))
	}

	fmt.Println(string(body))
}
```

{% endtab %}

{% tab title="Java" %}

```java
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Main {
  public static void main(String[] args) throws Exception {
    String payload = """
        {
          "templateXml": "{templateXml}",
          "envelopeXml": "{envelopeXml}",
          "signatureAlgorithm": "ECDSA_RSA",
          "signatureContainer": "P7S"
        }
        """;

    HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create(
            "https://api.docstudio.com/api/v1/envelope/one-time-send"
        ))
        .header(
            "Authorization",
            "Bearer {token}"
        )
        .header(
            "Mailbox",
            "{mailboxUuid}"
        )
        .header(
            "Content-Type",
            "application/json"
        )
        .header(
            "Accept",
            "application/json"
        )
        .POST(
            HttpRequest.BodyPublishers.ofString(payload)
        )
        .build();

    HttpResponse<String> response =
        HttpClient.newHttpClient().send(
            request,
            HttpResponse.BodyHandlers.ofString()
        );

    if (response.statusCode() < 200 ||
        response.statusCode() >= 300) {
      throw new RuntimeException(
          "Request failed: " +
          response.statusCode() +
          "\n" +
          response.body()
      );
    }

    System.out.println(response.body());
  }
}
```

{% endtab %}

{% tab title=".NET" %}

```csharp
using System.Net.Http.Headers;
using System.Net.Http.Json;

using var client = new HttpClient();

client.DefaultRequestHeaders.Authorization =
    new AuthenticationHeaderValue(
        "Bearer",
        "{token}"
    );

client.DefaultRequestHeaders.Add(
    "Mailbox",
    "{mailboxUuid}"
);

client.DefaultRequestHeaders.Add(
    "Accept",
    "application/json"
);

var payload = new
{
    templateXml = "{templateXml}",
    envelopeXml = "{envelopeXml}",
    signatureAlgorithm = "ECDSA_RSA",
    signatureContainer = "P7S"
};

using var response = await client.PostAsJsonAsync(
    "https://api.docstudio.com/api/v1/envelope/one-time-send",
    payload
);

var body =
    await response.Content.ReadAsStringAsync();

if (!response.IsSuccessStatusCode)
{
    throw new HttpRequestException(
        $"Request failed: " +
        $"{(int)response.StatusCode}\n{body}"
    );
}

Console.WriteLine(body);
```

{% endtab %}

{% tab title="cURL" %}

```bash
curl --request POST \
  --url 'https://api.docstudio.com/api/v1/envelope/one-time-send' \
  --header 'Authorization: Bearer {token}' \
  --header 'Mailbox: {mailboxUuid}' \
  --header 'Content-Type: application/json' \
  --header 'Accept: application/json' \
  --data '{
    "templateXml": "{templateXml}",
    "envelopeXml": "{envelopeXml}",
    "signatureAlgorithm": "ECDSA_RSA",
    "signatureContainer": "P7S"
  }'
```

{% endtab %}
{% endtabs %}

**Response**

A successful request returns `201 Created` with the created envelope UUID:

```json
{
  "uuid": "{envelopeUuid}"
}
```

### Error handling

Share-code sending can return `405 Method Not Allowed` when the server disables share-code sending. For complete error response schemas and status codes, use the [Swagger UI](https://api.docstudio.com/swagger-ui/index.html).

### Related topics

{% columns %}
{% column %}

* [Send Envelope](/api-reference/send-envelope.md)
* [Upload Attachments](/api-reference/upload-attachments.md)
* [Envelope Structure](/guides/envelope-structure.md)
* [XML payloads](/guides/xml-payloads.md)
  {% endcolumn %}

{% column %}

* [Templates and reusable IDs](/guides/templates-and-reusable-ids.md)
* [Search Mailboxes and Contacts](/api-reference/search-mailboxes-and-contacts.md)
* [Error handling and API error codes](/error-codes/error-handling-and-api-error-codes.md)
  {% endcolumn %}
  {% endcolumns %}