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

# Retrieve Template by ID

> Returns detailed information for document parser template by template's id.

## `GET /v1/pdf/documentparser/templates/:id`

Use the PDF.co dashbaord to manage your [Document Parser Templates](https://app.pdf.co/document-parser/templates).

<Note>Please refer to the [Document Parser Template Editor](https://app.pdf.co/document-parser/templates) and [PDF.co Document Parser: Template Creation Guide](/knowledgebase/document-parser-guide#document-parser-template-objects-guide) for more information.</Note>

## Query parameters

*No query parameters accepted.*

## Responses

| Parameter          | Type              | Description                                                          |
| ------------------ | ----------------- | -------------------------------------------------------------------- |
| `id`               | integer           | Unique identifier for the template                                   |
| `type`             | string            | Source of the template. The available sources are: `user`, `system`. |
| `title`            | string            | Title of the template                                                |
| `description`      | string            | Description of what the template does                                |
| `created_at`       | String (ISO 8601) | Timestamp indicating when the template was initially created         |
| `updated_at`       | String (ISO 8601) | Timestamp indicating the last time the template was modified         |
| `body`             | string            | Template content                                                     |
| `credits`          | integer           | Number of credits consumed by the request                            |
| `remainingCredits` | integer           | Number of credits remaining in the account                           |

<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>

## Code Samples

<Tabs>
  <Tab title="CURL">
    ```bash theme={null}
    curl --location --request GET 'https://api.pdf.co/v1/pdf/documentparser/templates/1' \
    --header 'Content-Type: application/json' \
    --header 'x-api-key: {{x-api-key}}' \
    --data-raw ''
    ```
  </Tab>

  <Tab title="JavaScript/Node.js">
    ```javascript theme={null}
    /*jshint esversion: 6 */
      var https = require("https");
      var path = require("path");
      var fs = require("fs");

      // `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 = "***********************************";

      // Source PDF file
      const SourceFile = "./MultiPageTable.pdf";
      // PDF document password. Leave empty for unprotected documents.
      const Password = "";
      // Destination PDF file name
      const DestinationFile = "./result.json";

      // 1. RETRIEVE PRESIGNED URL TO UPLOAD FILE.
      getPresignedUrl(API_KEY, SourceFile)
          .then(([uploadUrl, uploadedFileUrl]) => {
              // 2. UPLOAD THE FILE TO CLOUD.
              uploadFile(API_KEY, SourceFile, uploadUrl)
                  .then(() => {
                      // 3. OPTIMIZE UPLOADED PDF FILE
                      parsePdf(API_KEY, uploadedFileUrl, Password, DestinationFile);
                  })
                  .catch(e => {
                      console.log(e);
                  });
          })
          .catch(e => {
              console.log(e);
          });


      function getPresignedUrl(apiKey, localFile) {
          return new Promise(resolve => {
              // Prepare request to `Get Presigned URL` API endpoint
              let queryPath = `/v1/file/upload/get-presigned-url?contenttype=application/octet-stream&name=${path.basename(SourceFile)}`;
              let reqOptions = {
                  host: "api.pdf.co",
                  path: encodeURI(queryPath),
                  headers: { "x-api-key": API_KEY }
              };
              // Send request
              https.get(reqOptions, (response) => {
                  response.on("data", (d) => {
                      let data = JSON.parse(d);
                      if (data.error == false) {
                          // Return presigned url we received
                          resolve([data.presignedUrl, data.url]);
                      }
                      else {
                          // Service reported error
                          console.log("getPresignedUrl(): " + data.message);
                      }
                  });
              })
                  .on("error", (e) => {
                      // Request error
                      console.log("getPresignedUrl(): " + e);
                  });
          });
      }

      function uploadFile(apiKey, localFile, uploadUrl) {
          return new Promise(resolve => {
              fs.readFile(SourceFile, (err, data) => {
                  request({
                      method: "PUT",
                      url: uploadUrl,
                      body: data,
                      headers: {
                          "Content-Type": "application/octet-stream"
                      }
                  }, (err, res, body) => {
                      if (!err) {
                          resolve();
                      }
                      else {
                          console.log("uploadFile() request error: " + e);
                      }
                  });
              });
          });
      }

      function parsePdf(apiKey, uploadedFileUrl, password, destinationFile) {

          // Template text. Use Document Parser (https://pdf.co/document-parser, https://app.pdf.co/document-parser)
          // to create templates.
          // Read template from file:
          var templateText = fs.readFileSync("./MultiPageTable-template1.yml", "utf-8");

          // URL for `Document Parser` API call
          var query = `https://api.pdf.co/v1/pdf/documentparser`;
          var jsonRequestObject = {
              url: uploadedFileUrl,
              template: templateText
          };

          request(
              {
                  url: query,
                  headers: { "x-api-key": API_KEY },
                  method: "POST",
                  json: true,
                  body: jsonRequestObject
              },
              function (error, response, body) {

                  if (error) {
                      return console.error("Error: ", error);
                  }

                  // Parse JSON response
                  let data = JSON.parse(JSON.stringify(body));

                  if (data.error == false) {
                      //Download generated file
                      var file = fs.createWriteStream(destinationFile);
                      https.get(data.url, (response2) => {
                          response2.pipe(file)
                              .on("close", () => {
                                  console.log(`Generated result file saved as "${destinationFile}" file.`);
                              });
                      });
                  }
                  else {
                      // Service reported error
                      console.log("Error: " + data.message);
                  }
              }
          );
      }
    ```
  </Tab>

  <Tab title="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 = ".\\MultiPageTable.pdf"

    # Destination JSON file name
    DestinationFile = ".\\result.json"

    // Template text. Use Document Parser (https://pdf.co/document-parser, https://app.pdf.co/document-parser)
    # to create templates.
    # Read template from file:
    file_read = open(".\\MultiPageTable-template1.yml", mode='r', encoding="utf-8",errors="ignore")
    Template = file_read.read()
    file_read.close()

    def main(args = None):
        uploadedFileUrl = uploadFile(SourceFile)

        if (uploadedFileUrl != None):
            PerformDocumentParser(uploadedFileUrl, Template, DestinationFile)

    def PerformDocumentParser(uploadedFileUrl, template, destinationFile):

        # Content
        data = {
            'url': uploadedFileUrl,
            'template': template
        }

        # Prepare URL for 'Document Parser' API request
        url = "{}/pdf/documentparser".format(BASE_URL)

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

        if (response.status_code == 200):
            json = response.json()

            if json["error"] == False:
                #  Get URL of result file
                resultFileUrl = json["url"]
                # Download result file
                r = requests.get(resultFileUrl, stream=True)
                if (r.status_code == 200):
                    with open(destinationFile, 'wb') as file:
                        for chunk in r:
                            file.write(chunk)
                    print(f"Result file saved as \"{destinationFile}\" file.")
                else:
                    print(f"Request error: {response.status_code} {response.reason}")
            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()
    ```
  </Tab>

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

    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 = @".\MultiPageTable.pdf";
            // PDF document password. Leave empty for unprotected documents.
            const string Password = "";
            // Destination TXT file name
            const string DestinationFile = @".\result.json";

            static void Main(string[] args)
            {
                // Template text. Use Document Parser (https://pdf.co/document-parser, https://app.pdf.co/document-parser)
                // to create templates.
                // Read template from file:
                String templateText = File.ReadAllText(@".\MultiPageTable-template1.yml");

                // 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
                        webClient.Headers.Remove("content-type");

                        // 3. PARSE UPLOADED PDF DOCUMENT

                        // URL of `Document Parser` API call
                        string url = "https://api.pdf.co/v1/pdf/documentparser";

                        Dictionary<string, string> requestBody = new Dictionary<string, string>();
                        requestBody.Add("template", templateText);
                        requestBody.Add("name", Path.GetFileName(DestinationFile));
                        requestBody.Add("url", uploadedFileUrl);

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

                        // Execute request
                        response = webClient.UploadString(url, "POST", jsonPayload);

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

                        if (json["error"].ToObject<bool>() == false)
                        {
                            // Get URL of generated JSON file
                            string resultFileUrl = json["url"].ToString();

                            // Download JSON file
                            webClient.DownloadFile(resultFileUrl, DestinationFile);

                            Console.WriteLine("Generated JSON file saved as \"{0}\" file.", DestinationFile);
                        }
                        else
                        {
                            Console.WriteLine(json["message"].ToString());
                        }
                    }
                    else
                    {
                        Console.WriteLine(json["message"].ToString());
                    }
                }
                catch (WebException e)
                {
                    Console.WriteLine(e.ToString());
                }

                webClient.Dispose();

                Console.WriteLine();
                Console.WriteLine("Press any key...");
                Console.ReadKey();
            }
        }
    }
    ```
  </Tab>

  <Tab title="Java">
    ```java theme={null}
    package com.company;

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

    import java.io.File;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.OutputStream;
    import java.nio.charset.StandardCharsets;
    import java.nio.file.Files;
    import java.nio.file.Path;
    import java.nio.file.Paths;

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

        public static void main(String[] args) throws IOException
        {
            // Source PDF file
            final Path SourceFile = Paths.get(".\\MultiPageTable.pdf");
            // PDF document password. Leave empty for unprotected documents.
            final String Password = "";
            // Destination JSON file name
            final Path DestinationFile = Paths.get(".\\result.json");

            // Template text. Use Document Parser (https://pdf.co/document-parser, https://app.pdf.co/document-parser)
            // to create templates.
            // Read template from file:
            String templateText = new String(Files.readAllBytes(Paths.get(".\\MultiPageTable-template1.yml")), StandardCharsets.UTF_8);

            // Create HTTP client instance
            OkHttpClient webClient = new OkHttpClient();

            // 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 = String.format(
                    "https://api.pdf.co/v1/file/upload/get-presigned-url?contenttype=application/octet-stream&name=%s",
                    SourceFile.getFileName());

            // Prepare request
            Request request = new Request.Builder()
                    .url(query)
                    .addHeader("x-api-key", API_KEY) // (!) Set API Key
                    .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)
                {
                    // Get URL to use for the file upload
                    String uploadUrl = json.get("presignedUrl").getAsString();
                    // Get URL of uploaded file to use with later API calls
                    String uploadedFileUrl = json.get("url").getAsString();

                    // 2. UPLOAD THE FILE TO CLOUD.

                    if (uploadFile(webClient, API_KEY, uploadUrl, SourceFile))
                    {
                        // 3. PARSE UPLOADED PDF DOCUMENT

                        ParseDocument(webClient, API_KEY, DestinationFile, Password, uploadedFileUrl, templateText);
                    }
                }
                else
                {
                    // Display service reported error
                    System.out.println(json.get("message").getAsString());
                }
            }
            else
            {
                // Display request error
                System.out.println(response.code() + " " + response.message());
            }
        }

        public static void ParseDocument(OkHttpClient webClient, String apiKey, Path destinationFile,
            String password, String uploadedFileUrl, String templateText) throws IOException
        {
            // Prepare POST request body in JSON format
            JsonObject jsonBody = new JsonObject();
            jsonBody.add("url", new JsonPrimitive(uploadedFileUrl));
            jsonBody.add("template", new JsonPrimitive(templateText));

            RequestBody body = RequestBody.create(MediaType.parse("application/json"), jsonBody.toString());

            // Prepare request to `Document Parser` API
            Request request = new Request.Builder()
                    .url("https://api.pdf.co/v1/pdf/documentparser")
                    .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)
                {
                    // Get URL of generated JSON file
                    String resultFileUrl = json.get("url").getAsString();

                    // Download JSON file
                    downloadFile(webClient, resultFileUrl, destinationFile.toFile());

                    System.out.printf("Generated JSON file saved as \"%s\" file.", destinationFile.toString());
                }
                else
                {
                    // Display service reported error
                    System.out.println(json.get("message").getAsString());
                }
            }
            else
            {
                // Display request error
                System.out.println(response.code() + " " + response.message());
            }
        }

        public static boolean uploadFile(OkHttpClient webClient, String apiKey, String url, Path sourceFile) throws IOException
        {
            // Prepare request body
            RequestBody body = RequestBody.create(MediaType.parse("application/octet-stream"), sourceFile.toFile());

            // Prepare request
            Request request = new Request.Builder()
                    .url(url)
                    .addHeader("x-api-key", apiKey) // (!) Set API Key
                    .addHeader("content-type", "application/octet-stream")
                    .put(body)
                    .build();

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

            return (response.code() == 200);
        }

        public static void downloadFile(OkHttpClient webClient, String url, File destinationFile) throws IOException
        {
            // Prepare request
            Request request = new Request.Builder()
                    .url(url)
                    .build();
            // Execute request
            Response response = webClient.newCall(request).execute();

            byte[] fileBytes = response.body().bytes();

            // Save downloaded bytes to file
            OutputStream output = new FileOutputStream(destinationFile);
            output.write(fileBytes);
            output.flush();
            output.close();

            response.close();
        }
    }
    ```
  </Tab>

  <Tab title="PHP">
    ```php theme={null}
    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>Document Parse Results</title>
    </head>
    <body>

    <?php


    // Get submitted form data
    $apiKey = $_POST["apiKey"]; // The authentication key (API Key). Get your own by registering at https://app.pdf.co


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

    // Create URL
    $url = "https://api.pdf.co/v1/file/upload/get-presigned-url" .
        "?contenttype=application/octet-stream";

    // Create request
    $curl = curl_init();
    curl_setopt($curl, CURLOPT_HTTPHEADER, array("x-api-key: " . $apiKey));
    curl_setopt($curl, CURLOPT_URL, $url);
    curl_setopt($curl, CURLOPT_RETURNTRANSFER, 1);
    // Execute request
    $result = curl_exec($curl);

    if (curl_errno($curl) == 0)
    {
        $status_code = curl_getinfo($curl, CURLINFO_HTTP_CODE);

        if ($status_code == 200)
        {
            $json = json_decode($result, true);

            // Get URL to use for the file upload
            $uploadFileUrl = $json["presignedUrl"];
            // Get URL of uploaded file to use with later API calls
            $uploadedFileUrl = $json["url"];

            // 2. UPLOAD THE FILE TO CLOUD.

            $localFile = $_FILES["fileInput"]["tmp_name"];
            $fileHandle = fopen($localFile, "r");

            curl_setopt($curl, CURLOPT_URL, $uploadFileUrl);
            curl_setopt($curl, CURLOPT_HTTPHEADER, array("content-type: application/octet-stream"));
            curl_setopt($curl, CURLOPT_PUT, true);
            curl_setopt($curl, CURLOPT_INFILE, $fileHandle);
            curl_setopt($curl, CURLOPT_INFILESIZE, filesize($localFile));

            // Execute request
            curl_exec($curl);

            fclose($fileHandle);

            if (curl_errno($curl) == 0)
            {
                $status_code = curl_getinfo($curl, CURLINFO_HTTP_CODE);

                if ($status_code == 200)
                {
                    // Read all template texts
                    $templateText = file_get_contents($_FILES["fileTemplate"]["tmp_name"]);

                    // 3. PARSE UPLOADED PDF DOCUMENT
                    ParseDocument($apiKey, $uploadedFileUrl, $templateText);
                }
                else
                {
                    // Display request error
                    echo "<p>Status code: " . $status_code . "</p>";
                    echo "<p>" . $result . "</p>";
                }
            }
            else
            {
                // Display CURL error
                echo "Error: " . curl_error($curl);
            }
        }
        else
        {
            // Display service reported error
            echo "<p>Status code: " . $status_code . "</p>";
            echo "<p>" . $result . "</p>";
        }

        curl_close($curl);
    }
    else
    {
        // Display CURL error
        echo "Error: " . curl_error($curl);
    }

    function ParseDocument($apiKey, $uploadedFileUrl, $templateText)
    {
        // (!) Make asynchronous job
        $async = TRUE;

        // Prepare URL for Document parser API call.
        // See documentation: https://developer.pdf.co/api/document-parser/index.html
        $url = "https://api.pdf.co/v1/pdf/documentparser";

        // Prepare requests params
        $parameters = array();
        $parameters["url"] = $uploadedFileUrl;
        $parameters["template"] = $templateText;
        $parameters["async"] = $async;

        // Create Json payload
        $data = json_encode($parameters);

        // Create request
        $curl = curl_init();
        curl_setopt($curl, CURLOPT_HTTPHEADER, array("x-api-key: " . $apiKey, "Content-type: application/json"));
        curl_setopt($curl, CURLOPT_URL, $url);
        curl_setopt($curl, CURLOPT_POST, true);
        curl_setopt($curl, CURLOPT_RETURNTRANSFER, 1);
        curl_setopt($curl, CURLOPT_POSTFIELDS, $data);

        // Execute request
        $result = curl_exec($curl);
        echo $result . "<br/>";

        if (curl_errno($curl) == 0)
        {
            $status_code = curl_getinfo($curl, CURLINFO_HTTP_CODE);

            if ($status_code == 200)
            {
                $json = json_decode($result, true);

                if (!isset($json["error"]) || $json["error"] == false)
                {
                    // URL of generated JSON file that will available after the job completion
                    $resultFileUrl = $json["url"];
                    // Asynchronous job ID
                    $jobId = $json["jobId"];

                    // Check the job status in a loop
                    do
                    {
                        $status = CheckJobStatus($jobId, $apiKey); // Possible statuses: "working", "failed", "aborted", "success".

                        // Display timestamp and status (for demo purposes)
                        echo "<p>" . date(DATE_RFC2822) . ": " . $status . "</p>";

                        if ($status == "success")
                        {
                            // Display link to JSON file with information about parsed fields
                            echo "<div><h2>Parsing Result:</h2><a href='" . $resultFileUrl . "' target='_blank'>" . $resultFileUrl . "</a></div>";
                            break;
                        }
                        else if ($status == "working")
                        {
                            // Pause for a few seconds
                            sleep(3);
                        }
                        else
                        {
                            echo $status . "<br/>";
                            break;
                        }
                    }
                    while (true);
                }
                else
                {
                    // Display service reported error
                    echo "<p>Error: " . $json["message"] . "</p>";
                }
            }
            else
            {
                // Display request error
                echo "<p>Status code: " . $status_code . "</p>";
                echo "<p>" . $result . "</p>";
            }
        }
        else
        {
            // Display CURL error
            echo "Error: " . curl_error($curl);
        }
    }

    function CheckJobStatus($jobId, $apiKey)
    {
        $status = null;

        // Create URL
        $url = "https://api.pdf.co/v1/job/check";

        // Prepare requests params
        $parameters = array();
        $parameters["jobid"] = $jobId;

        // Create Json payload
        $data = json_encode($parameters);

        // Create request
        $curl = curl_init();
        curl_setopt($curl, CURLOPT_HTTPHEADER, array("x-api-key: " . $apiKey, "Content-type: application/json"));
        curl_setopt($curl, CURLOPT_URL, $url);
        curl_setopt($curl, CURLOPT_POST, true);
        curl_setopt($curl, CURLOPT_RETURNTRANSFER, 1);
        curl_setopt($curl, CURLOPT_POSTFIELDS, $data);

        // Execute request
        $result = curl_exec($curl);

        if (curl_errno($curl) == 0)
        {
            $status_code = curl_getinfo($curl, CURLINFO_HTTP_CODE);

            if ($status_code == 200)
            {
                $json = json_decode($result, true);

                if (!isset($json["error"]) || $json["error"] == false)
                {
                    $status = $json["status"];
                }
                else
                {
                    // Display service reported error
                    echo "<p>Error: " . $json["message"] . "</p>";
                }
            }
            else
            {
                // Display request error
                echo "<p>Status code: " . $status_code . "</p>";
                echo "<p>" . $result . "</p>";
            }
        }
        else
        {
            // Display CURL error
            echo "Error: " . curl_error($curl);
        }

        // Cleanup
        curl_close($curl);

        return $status;
    }

    ?>

    </body>
    </html>
    ```
  </Tab>
</Tabs>