> ## Documentation Index
> Fetch the complete documentation index at: https://developer.pdf.co/llms.txt
> Use this file to discover all available pages before exploring further.

# PDF Find Text

> Find text in PDF and get coordinates. Supports regular expressions.

<Note>
  **Try it live:** [PDF Find Text → API Tester](/api-tester/pdf-find/basic) — send a real request from your browser.
</Note>

## `POST /v1/pdf/find`

## Request body

<Note>Attributes are case-sensitive and should be inside JSON for POST request. for example: `{ "url": "https://example.com/file1.pdf" }` *No query parameters accepted.*</Note>

<Warning>When using regular expressions in JSON payloads, ensure that backslashes are properly escaped. For example, a single backslash `\` should be written as `\\`.</Warning>

<Note>To see the request size limits, please refer to the [Request Size Limits](/api/url-input-and-request-limits#pdf-co-request-size).</Note>

<ParamField body="url" type="string" required>
  URL to the source file [`url` attribute](/api/url-input-and-request-limits#supported-file-sources)
</ParamField>

<ParamField body="callback" type="string">
  The callback URL (or Webhook) used to receive the POST data. see [Webhooks & Callbacks](/api/webhooks). This is only applicable when `async` is set to `true`.
</ParamField>

<ParamField body="httpusername" type="string">
  HTTP auth user name if required to access source URL.
</ParamField>

<ParamField body="httppassword" type="string">
  HTTP auth password if required to access source URL.
</ParamField>

<ParamField body="pages" type="string" default="all pages">
  Specify page indices as comma-separated values or ranges to process (e.g. "0, 1, 2-" or "1, 2, 3-7"). The first-page index is 0. Use "!" before a number for inverted page numbers (e.g. "!0" for the last page). If not specified, the default configuration processes all pages. The input must be in string format.
</ParamField>

<ParamField body="inline" type="boolean" default="true">
  Set to true to return results inside the response. Otherwise, the endpoint will return a URL to the output file generated.
</ParamField>

<ParamField body="password" type="string">
  Password for the PDF file.
</ParamField>

<ParamField body="async" type="boolean" default="false">
  Set `async` to `true` for long processes to run in the background, API will then return a `jobId` which you can use with the [Background Job Check endpoint](/api/job-check). Also see [Webhooks & Callbacks](/api/webhooks)
</ParamField>

<ParamField body="searchString" type="string" required>
  Text to search can support regular expressions if you set the `regexSearch` param to true.
</ParamField>

<ParamField body="wordMatchingMode" type="string" default="SmartMatch">
  WordMatchingMode defines how search terms match PDF text. Modes: `None` (exact string match only), `SmartMatch` (default; flexible word boundary match, includes letters/digits/punctuation), `ExactMatch` (strict word boundaries, whole-word match only).
</ParamField>

<ParamField body="regexSearch" type="boolean" default="false">
  Set to true to enable regular expression search for the `searchString(s)` parameter.
</ParamField>

<ParamField body="profiles" type="string">
  See [Profiles](/api/profiles) for more information.
</ParamField>

<Expandable title="profiles properties">
  | Setting | Type | Description |
  | - | - | - |
  | `OCRMode` | string (default `Auto`) | Specifies how OCR (Optical Character Recognition) should process input content, offering various modes to tailor text extraction based on content type such as images, fonts, and vector graphics. For more information, see [OCR Extraction Modes](/api/profiles#ocr-optical-character-recognition-mode-options). |
  | `OCRLanguage` | string | Sets the OCR language used during text search. |
  | `ExtractionAreaUsageMode` | string | Controls how extraction areas are applied during text search. |
  | `DataEncryptionAlgorithm` | string | Controls the encryption algorithm used for data encryption. See [User-Controlled Encryption](/knowledgebase/user-controlled-encryption) for more information. The available algorithms are: `AES128`, `AES192`, `AES256`. |
  | `DataEncryptionKey` | string | Controls the encryption key used for data encryption. See [User-Controlled Encryption](/knowledgebase/user-controlled-encryption) for more information. |
  | `DataEncryptionIV` | string | Controls the encryption IV used for data encryption. See [User-Controlled Encryption](/knowledgebase/user-controlled-encryption) for more information. |
  | `DataDecryptionAlgorithm` | string | Controls the decryption algorithm used for data decryption. See [User-Controlled Encryption](/knowledgebase/user-controlled-encryption) for more information. The available algorithms are: `AES128`, `AES192`, `AES256`. |
  | `DataDecryptionKey` | string | Controls the decryption key used for data decryption. See [User-Controlled Encryption](/knowledgebase/user-controlled-encryption) for more information. |
  | `DataDecryptionIV` | string | Controls the decryption IV used for data decryption. See [User-Controlled Encryption](/knowledgebase/user-controlled-encryption) for more information. |
</Expandable>

### Support page rotation

OCR page rotation detection is enabled automatically by this endpoint.

### Find only bordered tables

The profiles listed above do not configure table-detection modes for this endpoint. For searches in bordered tables, use the [PDF Find Table endpoint](/api/pdf-find/table).

## Responses

```json Synchronous response theme={null}
{
  "body": [
    {
      "text": "Invoice Date 01/01/2016",
      "left": 436.5400085449219,
      "top": 130.4599995137751,
      "width": 122.85311957550027,
      "height": 11.040000486224898,
      "pageIndex": 0,
      "bounds": {
        "location": {
          "isEmpty": false,
          "x": 436.54,
          "y": 130.46
        },
        "size": "122.853119, 11.0400009",
        "x": 436.54,
        "y": 130.46,
        "width": 122.853119,
        "height": 11.0400009,
        "left": 436.54,
        "top": 130.46,
        "right": 559.3931,
        "bottom": 141.5,
        "isEmpty": false
      },
      "elementCount": 1,
      "elements": [
        {
          "index": 0,
          "left": 436.5400085449219,
          "top": 130.4599995137751,
          "width": 122.85311957550027,
          "height": 11.040000486224898,
          "angle": 0,
          "text": "Invoice Date 01/01/2016",
          "isNewLine": true,
          "fontIsBold": true,
          "fontIsItalic": false,
          "fontName": "Helvetica-Bold",
          "fontSize": 11,
          "fontColor": "0, 0, 0",
          "fontColorAsOleColor": 0,
          "fontColorAsHtmlColor": "#000000",
          "bounds": {
            "location": {
              "isEmpty": false,
              "x": 436.54,
              "y": 130.46
            },
            "size": "122.853119, 11.0400009",
            "x": 436.54,
            "y": 130.46,
            "width": 122.853119,
            "height": 11.0400009,
            "left": 436.54,
            "top": 130.46,
            "right": 559.3931,
            "bottom": 141.5,
            "isEmpty": false
          }
        }
      ]
    }
  ],
  "pageCount": 1,
  "error": false,
  "status": 200,
  "name": "output",
  "remainingCredits": 59970
}
```

### Inline match fields

When `inline` is `true` (the default), `body` is an array of match objects. When `inline` is `false`, `url` points to a JSON file containing that array. An asynchronous request returns a `jobId` and a reserved `url`; use the URL only after the job succeeds.

| Path | Type | Description |
| - | - | - |
| `body[]` | object | One matching text result. |
| `body[].text` | string | Matched text. |
| `body[].left`, `body[].top`, `body[].width`, `body[].height` | number | Match rectangle in the page. |
| `body[].pageIndex` | integer | Zero-based page index containing the match. |
| `body[].bounds.location` | object | Match location, including `x`, `y`, and `isEmpty`. |
| `body[].bounds.size` | string | Match size. |
| `body[].bounds.x`, `body[].bounds.y`, `body[].bounds.width`, `body[].bounds.height`, `body[].bounds.left`, `body[].bounds.top`, `body[].bounds.right`, `body[].bounds.bottom` | number | Match rectangle coordinates and dimensions. |
| `body[].bounds.isEmpty` | boolean | Whether the bounds are empty. |
| `body[].elementCount` | integer | Number of text elements in the match. |
| `body[].elements[]` | object | Text element details, including coordinates, text, font, style, and bounds. |

### HTTP response metadata

| Field | Type | Description |
| - | - | - |
| `url` | string | URL for the JSON output file when results are not returned inline. In an asynchronous initial response, this is reserved until the job succeeds. |
| `outputLinkValidTill` | string | Timestamp when the output link will expire. |
| `body` | array\[object] | Present when `inline` is `true`; see [Inline match fields](#inline-match-fields). |
| `pageCount` | integer | Number of pages processed. |
| `error` | boolean | Indicates whether an error occurred (`false` means success) |
| `status` | integer or string | The numeric status code of the operation, or the string `"error"`; when it is `"error"`, the numeric code is in `errorCode`. The `429` rate-limit response has no `status` field. In all cases, rely on the HTTP status code of the response. |
| `message` | string | Error message, when present. |
| `credits` | integer | Number of credits consumed by the request, when present. |
| `remainingCredits` | integer | Number of credits remaining in the account, when present. |
| `duration` | integer | Time taken for the operation in milliseconds, when present. |
| `errorCode` | integer | Numeric error code in gateway authentication and other error responses that include it. |
| `jobId` | string | Present in the initial response when `async` is `true`. |

Poll asynchronous requests via [Background Job Check](/api/job-check). Error response bodies vary by failure source: authentication errors use `status: "error"` with `errorCode`, while gateway rate-limit responses omit `status`.

<Note>
  **Inconsistent URL Encoding in cURL Output:** When using cURL to make API requests, the output JSON may show URL characters encoded as Unicode escape sequences. For example, the ampersand character (`&`) may appear as `\u0026` in the cURL output. This is normal JSON encoding behavior and does not affect the validity of the URL. The URL will function correctly when used, as JSON parsers automatically decode these escape sequences. If you're parsing the response programmatically, your JSON parser will handle this conversion automatically.
</Note>

<div id="code-samples" />

<Panel>
  **Sample request**

  <RequestExample dropdown>
    ```bash CURL theme={null}
    curl --location --request POST 'https://api.pdf.co/v1/pdf/find' \
    --header 'x-api-key: *******************' \
    --header 'Content-Type: application/json' \
    --data-raw '{
    "async": "false",
    "url": "https://pdfco-test-files.s3.us-west-2.amazonaws.com/pdf-to-text/sample.pdf",
    "searchString": "Invoice Date \\d+/\\d+/\\d+",
    "regexSearch": "true",
    "name": "output",
    "pages": "0-",
    "inline": "true",
    "wordMatchingMode": "",
    "password": ""
    }'
    ```

    ```javascript JavaScript/Node.js theme={null}
    // `request` module is required for file upload.
    // Use "npm install request" command to install.
    var request = require("request");

    // The authentication key (API Key).
    // Get your own by registering at https://app.pdf.co
    const API_KEY = "***********************************";

    // Direct URL of source PDF file.
    const SourceFileUrl = "https://pdfco-test-files.s3.us-west-2.amazonaws.com/pdf-to-text/sample.pdf";

    // Comma-separated list of page indices (or ranges) to process. Leave empty for all pages. Example: '0,2-5,7-'.
    const Pages = "";

    // PDF document password. Leave empty for unprotected documents.
    const Password = "";

    // Search string.
    const SearchString = '[4-9][0-9].[0-9][0-9]'; // Regular expression to find numbers in format dd.dd and between 40.00 to 99.99

    // Enable regular expressions (Regex)
    const RegexSearch = 'True';

    // Prepare URL for PDF text search API call.
    // See documentation: https://developer.pdf.co
    var query = `https://api.pdf.co/v1/pdf/find`;
    let reqOptions = {
        uri: query,
        headers: { "x-api-key": API_KEY },
        formData: {
            password: Password,
            pages: Pages,
            url: SourceFileUrl,
            searchString: SearchString,
            regexSearch: RegexSearch
        }
    };

    // Send request
    request.post(reqOptions, function (error, response, body) {
        if (error) {
            return console.error("Error: ", error);
        }

        // Parse JSON response
        let data = JSON.parse(body);
        for (let index = 0; index < data.body.length; index++) {
            const element = data.body[index];
            console.log("Found text " + element["text"] + " at coordinates " + element["left"] + ", " + element["top"]);
        }

    });
    ```

    ```python Python theme={null}
    import os
    import requests # pip install requests

    # The authentication key (API Key).
    # Get your own by registering at https://app.pdf.co
    API_KEY = "******************************************"

    # Base URL for PDF.co Web API requests
    BASE_URL = "https://api.pdf.co/v1"

    # Source PDF file
    SourceFile = ".\\sample.pdf"

    # Comma-separated list of page indices (or ranges) to process. Leave empty for all pages. Example: '0,2-5,7-'.
    Pages = ""

    # PDF document password. Leave empty for unprotected documents.
    Password = ""

    # Search string.
    SearchString = "\d{1,}\.\d\d" # Regular expression to find numbers like '100.00'
                                  # Note: do not use `+` char in regex, but use `{1,}` instead.
                                  # `+` char is valid for URL and will not be escaped, and it will become a space char on the server side.

    # Enable regular expressions (Regex)
    RegexSearch = True


    def main(args = None):
        uploadedFileUrl = uploadFile(SourceFile)
        if (uploadedFileUrl != None):
            searchTextInPDF(uploadedFileUrl)


    def searchTextInPDF(uploadedFileUrl):
        """Search Text using PDF.co Web API"""

        # Prepare requests params as JSON
        # See documentation: https://developer.pdf.co
        parameters = {}
        parameters["password"] = Password
        parameters["pages"] = Pages
        parameters["url"] = uploadedFileUrl
        parameters["searchString"] = SearchString
        parameters["regexSearch"] = RegexSearch

        # Prepare URL for 'PDF Text Search' API request
        url = "{}/pdf/find".format(BASE_URL)

        # Execute request and get response as JSON
        response = requests.post(url, data=parameters, headers={ "x-api-key": API_KEY })
        if (response.status_code == 200):
            json = response.json()

            if json["error"] == False:
                # Display found information
                for item in json["body"]:
                    print(f"Found text {item['text']} at coordinates {item['left']}, {item['top']}")
            else:
                # Show service reported error
                print(json["message"])
        else:
            print(f"Request error: {response.status_code} {response.reason}")


    def uploadFile(fileName):
        """Uploads file to the cloud"""

        # 1. RETRIEVE PRESIGNED URL TO UPLOAD FILE.

        # Prepare URL for 'Get Presigned URL' API request
        url = "{}/file/upload/get-presigned-url?contenttype=application/octet-stream&name={}".format(
            BASE_URL, os.path.basename(fileName))

        # Execute request and get response as JSON
        response = requests.get(url, headers={ "x-api-key": API_KEY })
        if (response.status_code == 200):
            json = response.json()

            if json["error"] == False:
                # URL to use for file upload
                uploadUrl = json["presignedUrl"]
                # URL for future reference
                uploadedFileUrl = json["url"]

                # 2. UPLOAD FILE TO CLOUD.
                with open(fileName, 'rb') as file:
                    requests.put(uploadUrl, data=file, headers={ "x-api-key": API_KEY, "content-type": "application/octet-stream" })

                return uploadedFileUrl
            else:
                # Show service reported error
                print(json["message"])
        else:
            print(f"Request error: {response.status_code} {response.reason}")

        return None


    if __name__ == '__main__':
        main()
    ```

    ```csharp C# theme={null}
    using System;
    using System.Collections.Generic;
    using System.IO;
    using System.Net;
    using Newtonsoft.Json;
    using Newtonsoft.Json.Linq;

    namespace PDFcoApiExample
    {
        class Program
        {
            // The authentication key (API Key).
            // Get your own by registering at https://app.pdf.co
            const String API_KEY = "*********************************";

            // Source PDF file
            const string SourceFile = @".\sample.pdf";

            // Comma-separated list of page indices (or ranges) to process. Leave empty for all pages. Example: '0,2-5,7-'.
            const string Pages = "";

            // PDF document password. Leave empty for unprotected documents.
            const string Password = "";

            // Search string.
            const string SearchString = @"\d{1,}\.\d\d"; // Regular expression to find numbers like '100.00'
                                                         // Note: do not use `+` char in regex, but use `{1,}` instead.
                                                         // `+` char is valid for URL and will not be escaped, and it will become a space char on the server side.

            // Enable regular expressions (Regex)
            const bool RegexSearch = true;


            static void Main(string[] args)
            {
                // Create standard .NET web client instance
                WebClient webClient = new WebClient();

                // Set API Key
                webClient.Headers.Add("x-api-key", API_KEY);

                // 1. RETRIEVE THE PRESIGNED URL TO UPLOAD THE FILE.
                // * If you already have a direct file URL, skip to the step 3.

                // Prepare URL for `Get Presigned URL` API call
                string query = Uri.EscapeUriString(string.Format(
                    "https://api.pdf.co/v1/file/upload/get-presigned-url?contenttype=application/octet-stream&name={0}",
                    Path.GetFileName(SourceFile)));

                try
                {
                    // Execute request
                    string response = webClient.DownloadString(query);

                    // Parse JSON response
                    JObject json = JObject.Parse(response);

                    if (json["error"].ToObject<bool>() == false)
                    {
                        // Get URL to use for the file upload
                        string uploadUrl = json["presignedUrl"].ToString();
                        string uploadedFileUrl = json["url"].ToString();

                        // 2. UPLOAD THE FILE TO CLOUD.
                        webClient.Headers.Add("content-type", "application/octet-stream");
                        webClient.UploadFile(uploadUrl, "PUT", SourceFile); // You can use UploadData() instead if your file is byte[] or Stream

                        // 3. MAKE UPLOADED PDF FILE SEARCHABLE

                        // URL for `PDF Text Search` API call
                        // See documentation: https://developer.pdf.co
                        string url = "https://api.pdf.co/v1/pdf/find";

                        // Prepare requests params as JSON
                        Dictionary<string, object> parameters = new Dictionary<string, object>();
                        parameters.Add("password", Password);
                        parameters.Add("pages", Pages);
                        parameters.Add("url", uploadedFileUrl);
                        parameters.Add("searchString", SearchString);
                        parameters.Add("regexSearch", RegexSearch);

                        // Convert dictionary of params to JSON
                        string jsonPayload = JsonConvert.SerializeObject(parameters);

                        // Execute POST request with JSON payload
                        response = webClient.UploadString(url, jsonPayload);

                        // Parse JSON response
                        json = JObject.Parse(response);

                        if (json["error"].ToObject<bool>() == false)
                        {
                            foreach (JToken item in json["body"])
                            {
                                Console.WriteLine($"Found text \"{item["text"]}\" at coordinates {item["left"]}, {item["top"]}");
                            }
                        }
                        else
                        {
                            Console.WriteLine(json["message"].ToString());
                        }
                    }
                    else
                    {
                        Console.WriteLine(json["message"].ToString());
                    }
                }
                catch (WebException ex)
                {
                    Console.WriteLine(ex.ToString());
                }

                webClient.Dispose();

                Console.WriteLine();
                Console.WriteLine("Press any key...");
                Console.ReadKey();
            }
        }
    }
    ```

    ```java Java theme={null}
    package com.company;

    import com.google.gson.JsonElement;
    import com.google.gson.JsonObject;
    import com.google.gson.JsonParser;
    import okhttp3.*;

    import java.io.*;
    import java.net.*;

    public class Main
    {
        // The authentication key (API Key).
        // Get your own by registering at https://app.pdf.co
        final static String API_KEY = "***********************************";

        // Direct URL of source PDF file.
        final static String SourceFileURL = "https://pdfco-test-files.s3.us-west-2.amazonaws.com/pdf-to-text/sample.pdf";

        // Comma-separated list of page indices (or ranges) to process. Leave empty for all pages. Example: '0,2-5,7-'.
        final static String Pages = "";

        // PDF document password. Leave empty for unprotected documents.
      final static String Password = "";

        // Search string.
      final static String SearchString = "\\d{1,}\\.\\d\\d"; // Regular expression to find numbers like '100.00'
        // Note: do not use `+` char in regex, but use `{1,}` instead.
        // `+` char is valid for URL and will not be escaped, and it will become a space char on the server side.

        // Enable regular expressions (Regex)
        final static boolean RegexSearch = true;

        public static void main(String[] args) throws IOException
        {
            // Create HTTP client instance
            OkHttpClient webClient = new OkHttpClient();

            // Prepare URL for PDF text search API call.
            // See documentation: https://developer.pdf.co
            String query = "https://api.pdf.co/v1/pdf/find";

            // Make correctly escaped (encoded) URL
            URL url = null;
            try
            {
                url = new URI(null, query, null).toURL();
            }
            catch (URISyntaxException e)
            {
                e.printStackTrace();
            }

            // Create JSON payload
        String jsonPayload = String.format("{\"password\": \"%s\", \"pages\": \"%s\", \"url\": \"%s\", \"searchString\": \"%s\", \"regexSearch\": \"%s\"}",
                    Password,
                    Pages,
                    SourceFileURL,
                    SearchString,
                    RegexSearch);

            // Prepare request body
            RequestBody body = RequestBody.create(MediaType.parse("application/json"), jsonPayload);

            // Prepare request
            Request request = new Request.Builder()
                .url(url)
                .addHeader("x-api-key", API_KEY) // (!) Set API Key
                .addHeader("Content-Type", "application/json")
                .post(body)
                .build();

            // Execute request
            Response response = webClient.newCall(request).execute();

            if (response.code() == 200)
            {
                // Parse JSON response
                JsonObject json = new JsonParser().parse(response.body().string()).getAsJsonObject();

                boolean error = json.get("error").getAsBoolean();
                if (!error)
                {
                    // Display found items in console
                    for (JsonElement element : json.get("body").getAsJsonArray())
                    {
                        JsonObject item = (JsonObject) element;
                        System.out.println("Found text " + item.get("text") + " at coordinates " + item.get("left") + ", "+ item.get("top"));
                    }
                }
                else
                {
                    // Display service reported error
                    System.out.println(json.get("message").getAsString());
                }
            }
            else
            {
                // Display request error
                System.out.println(response.code() + " " + response.message());
            }
        }
    }
    ```
  </RequestExample>

  <ResponseExample>
    ```json 200 theme={null}
    {
      "body": [
        {
          "text": "Invoice Date 01/01/2016",
          "left": 436.5400085449219,
          "top": 130.4599995137751,
          "width": 122.85311957550027,
          "height": 11.040000486224898,
          "pageIndex": 0,
          "bounds": {
            "location": {
              "isEmpty": false,
              "x": 436.54,
              "y": 130.46
            },
            "size": "122.853119, 11.0400009",
            "x": 436.54,
            "y": 130.46,
            "width": 122.853119,
            "height": 11.0400009,
            "left": 436.54,
            "top": 130.46,
            "right": 559.3931,
            "bottom": 141.5,
            "isEmpty": false
          },
          "elementCount": 1,
          "elements": [
            {
              "index": 0,
              "left": 436.5400085449219,
              "top": 130.4599995137751,
              "width": 122.85311957550027,
              "height": 11.040000486224898,
              "angle": 0,
              "text": "Invoice Date 01/01/2016",
              "isNewLine": true,
              "fontIsBold": true,
              "fontIsItalic": false,
              "fontName": "Helvetica-Bold",
              "fontSize": 11,
              "fontColor": "0, 0, 0",
              "fontColorAsOleColor": 0,
              "fontColorAsHtmlColor": "#000000",
              "bounds": {
                "location": {
                  "isEmpty": false,
                  "x": 436.54,
                  "y": 130.46
                },
                "size": "122.853119, 11.0400009",
                "x": 436.54,
                "y": 130.46,
                "width": 122.853119,
                "height": 11.0400009,
                "left": 436.54,
                "top": 130.46,
                "right": 559.3931,
                "bottom": 141.5,
                "isEmpty": false
              }
            }
          ]
        }
      ],
      "pageCount": 1,
      "error": false,
      "status": 200,
      "name": "output",
      "remainingCredits": 59970
    }
    ```

    ```json 400 theme={null}
    {
      "error": true,
      "status": 400,
      "message": "Bad request. Typically due to bad input parameters or unreachable input URLs (e.g., access restrictions like login or password)."
    }
    ```

    ```json 401 theme={null}
    {
      "status": "error",
      "errorCode": 401,
      "error": true,
      "message": "Please provide your API key as \"x-api-key\" header parameter for GET or POST request or as username (\"curl -u <apikey>\") or as url parameter (not recommended). Get your API key at https://app.pdf.co/account"
    }
    ```

    ```json 402 theme={null}
    {
      "status": "error",
      "errorCode": 402,
      "error": true,
      "message": "Not enough credits, subscription expired or metered use is not allowed. Please review credits on your account at https://app.pdf.co/subscriptions"
    }
    ```

    ```json 403 theme={null}
    {
      "error": true,
      "status": 403,
      "message": "Access forbidden for input URL."
    }
    ```

    ```json 404 theme={null}
    {
      "error": true,
      "status": 404,
      "message": "The requested resource could not be found."
    }
    ```

    ```json 408 theme={null}
    {
      "error": true,
      "status": 408,
      "message": "The server timed out waiting for the request."
    }
    ```

    ```json 429 theme={null}
    {
      "error": true,
      "message": "Too many requests. Your current limit is <limit> requests per minute. Please try again later"
    }
    ```

    ```json 441 theme={null}
    {
      "error": true,
      "status": 441,
      "message": "Invalid Password. Password protected document."
    }
    ```

    ```json 442 theme={null}
    {
      "error": true,
      "status": 442,
      "message": "Input document is damaged or of incorrect type."
    }
    ```

    ```json 444 theme={null}
    {
      "error": true,
      "status": 444,
      "message": "Profiles parsing error. Please ensure that the configuration is supported."
    }
    ```

    ```json 445 theme={null}
    {
      "error": true,
      "status": 445,
      "message": "Timeout error. For large documents, use asynchronous mode (async=true) and check status via /job/check."
    }
    ```

    ```json 446 theme={null}
    {
      "error": true,
      "status": 446,
      "message": "Some files required for conversion are missing."
    }
    ```

    ```json 450 theme={null}
    {
      "error": true,
      "status": 450,
      "message": "Invalid page range specified."
    }
    ```

    ```json 452 theme={null}
    {
      "error": true,
      "status": 452,
      "message": "Invalid URL."
    }
    ```

    ```json 454 theme={null}
    {
      "error": true,
      "status": 454,
      "message": "Invalid parameters."
    }
    ```

    ```json 500 theme={null}
    {
      "error": true,
      "status": 500,
      "message": "Something went wrong. Please try again or contact support."
    }
    ```
  </ResponseExample>
</Panel>


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.