PDF.co Web API – PDF To Image API – JavaScript – Convert PDF To JPEG From Uploaded File (Node.js)

Source Code:

This sample using NodeJS, and also available on our GitHub Repository. This sample is also available in other programming languages, like C#, Java, Python, etc. Please explore our GitHub Repository for more information.

app.js

      
/*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/documentation/api
const API_KEY = "***********************************";


// Source PDF file
const SourceFile = "./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 = "";


// 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. CONVERT UPLOADED PDF FILE TO JPEG
                convertPdfToJpeg(API_KEY, uploadedFileUrl, Password, Pages);
            })
            .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 convertPdfToJpeg(apiKey, uploadedFileUrl, password, pages) {
    // Prepare URL for `PDF To JPEG` API call
    var queryPath = `/v1/pdf/convert/to/jpg`;

    // JSON payload for api request
    var jsonPayload = JSON.stringify({
        password: password, pages: pages, url: uploadedFileUrl
    });

    var reqOptions = {
        host: "api.pdf.co",
        method: "POST",
        path: queryPath,
        headers: {
            "x-api-key": API_KEY,
            "Content-Type": "application/json",
            "Content-Length": Buffer.byteLength(jsonPayload, 'utf8')
        }
    };
    // Send request
    var postRequest = https.request(reqOptions, (response) => {
        response.on("data", (d) => {
            response.setEncoding("utf8");
            // Parse JSON response
            let data = JSON.parse(d);
            if (data.error == false) {
                // Download generated JPEG files
                var page = 1;
                data.urls.forEach((url) => {
                    var localFileName = `./page${page}.jpg`;
                    var file = fs.createWriteStream(localFileName);
                    https.get(url, (response2) => {
                        response2.pipe(file)
                            .on("close", () => {
                                console.log(`Generated JPEG file saved as "${localFileName}" file.`);
                            });
                    });
                    page++;
                }, this);
            }
            else {
                // Service reported error
                console.log("convertPdfToJpeg(): " + data.message);
            }
        });
    })
        .on("error", (e) => {
            // Request error
            console.log("convertPdfToJpeg(): " + e);
        });

    // Write request data
    postRequest.write(jsonPayload);
    postRequest.end();

}
    

package.json

      
{
  "name": "test",
  "version": "1.0.0",
  "description": "PDF.co",
  "main": "app.js",
  "scripts": {
  },
  "keywords": [
    "pdf.co",
    "web",
    "api",
    "bytescout",
    "api"
  ],
  "author": "ByteScout & PDF.co",
  "license": "ISC",
  "dependencies": {
    "request": "^2.88.2"
  }
}

    

Output:

The output of the above sample is as follows.

Now that we’ve observed the code snippet and the output, let’s analyze the code briefly.

Initially, we’re just importing node modules and declaring variables such as PDF.co API Key, source file, pages to be converted to image, etc.

After that, we’re performing the upload of the input PDF file by calling method getPresignedUrl. This method getPresignedUrl will get us two URLs, one will refer to the uploaded PDF file and the other URL is put request URL where a file should be uploaded. Once the response is received, we’re performing the actual upload of file by invoking uploadFile method.

With all File Upload portion complete, the code is now proceeding with PDF to JPG conversion. This is a straight forward approach like, we’re preparing the request URL, then preparing the JSON payload for that request, invoking API and getting the response.

Request URL in this case is /v1/pdf/convert/to/jpg, to get more information regarding this API endpoint please refer to documentation for PDF.co APIs. The JSON payload contains the basic information such as input URL, pages to be converted, etc. The response contains the array of output URLs, we’re saving each of URL to the physical file.

With this, we’re done with converting PDF to Image. This is a very simple sample with a basic API call, we can explore documentation for advanced options available and configure as per our needs.

Please try to do it in your machine to get more idea. Thanks for reading!

ON-PREMISE OFFLINE SDK

Get 60 Day Free Trial

See also:

• Explore Documentation
• Explore Source Code Samples
• Watch Video Course

ON-DEMAND REST WEB API

Get Your API Key

See also:

• Web API Docs
• Learn About Security
• Explore Source Code Samples