Code samples

Ruby (using standard library)
This Ruby example creates creates a new PDF job. It reads the API key from the PAPERPLANE_API_KEY environment variable, so make sure you have that configured.
require "uri"
require "net/http"
​
endpoint = URI.parse("https://api.paperplane.app/jobs")
http = Net::HTTP.new(endpoint.host, endpoint.port)
http.use_ssl = true
​
request = Net::HTTP::Post.new(endpoint.request_uri)
request.basic_auth(ENV.fetch("PAPERPLANE_API_KEY"), "")
request.set_form_data(
  "url" => "https://en.wikipedia.org/wiki/Airplane",
  "page_size" => "A4"
)
​
response = http.request(request)
puts response.body
Ruby (using the HTTP gem)
This Ruby example uses the HTTP gem which provides a more convenient API than the standard library packages.
# gem install http
​
require "http"
​
response = HTTP.basic_auth(user: ENV.fetch("PAPERPLANE_API_KEY"), pass: "").post(
  "https://api.paperplane.app/jobs",
  json: { url: "https://en.wikipedia.org/wiki/Airplane", page_size: "A4" }
)
​
puts response.body
Python
This Python example creates creates a new PDF job. It reads the API key from the PAPERPLANE_API_KEY environment variable, so make sure you have that configured.
The requests library is used for making HTTP requests, so you'll need to have that installed.
# pip install requests
​
import os
import requests
​
response = requests.post(
    'https://api.paperplane.app/jobs',
    auth=(os.getenv('PAPERPLANE_API_KEY'), ''),
    data={'url': 'https://en.wikipedia.org/wiki/Airplane', 'page_size': 'A4'}
)
​
print(response.json())
PHP
This example creates creates a new PDF job. It reads the API key from the PAPERPLANE_API_KEY environment variable, so make sure you have that configured.
<?php
​
$curl = curl_init();
​
curl_setopt_array($curl, array(
  CURLOPT_URL => 'https://api.paperplane.app/jobs',
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_POST => true,
  CURLOPT_POSTFIELDS => array(
    'url' => 'https://en.wikipedia.org/wiki/Airplane',
    'page_size' => 'A4'
  ),
  CURLOPT_USERNAME => getenv('PAPERPLANE_API_KEY')
));
​
$response = curl_exec($curl);
​
curl_close($curl);
​
echo $response;
​
?>
Node.js
This snippet creates creates a new PDF job. It reads the API key from the PAPERPLANE_API_KEY environment variable, so make sure you have that configured.
This example uses the node-fetch library for making HTTP requests.
// npm install node-fetch
​
const fetch = require("node-fetch");
​
const url = "https://api.paperplane.app/jobs";
​
async function createPdf() {
  const auth = new Buffer(process.env.PAPERPLANE_API_KEY + ":").toString(
    "base64"
  );
  const response = await fetch(url, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      Authorization: `Basic ${auth}`
    },
    body: JSON.stringify({
      url: "https://en.wikipedia.org/wiki/Airplane",
      page_size: "A4"
    })
  });
  const json = await response.json();
  console.log(json);
};
​
createPdf();
Java
This snippet creates creates a new PDF job. It reads the API key from the PAPERPLANE_API_KEY environment variable, so make sure you have that configured.
This example uses the Apache HttpComponents library for making HTTP requests.
package com.mycompany.app;
​
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.List;
​
import org.apache.commons.codec.binary.Base64;
import org.apache.http.HttpEntity;
import org.apache.http.HttpHeaders;
import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.client.HttpClient;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;
​
public class App {
    public static void main(String[] args) {
        try {
            // Construct the auth header.
            String apiKey = System.getenv("PAPERPLANE_API_KEY");
            String auth = apiKey + ":";
            byte[] authEncoded = Base64.encodeBase64(auth.getBytes(StandardCharsets.ISO_8859_1));
            String authHeader = "Basic " + new String(authEncoded);
            HttpPost request = new HttpPost("https://api.paperplane.app/jobs");
            request.setHeader(HttpHeaders.AUTHORIZATION, authHeader);
​
            // Create form data to specify our URL and set some options.
            List<NameValuePair> params = new ArrayList<NameValuePair>();
            params.add(new BasicNameValuePair("url", "https://en.wikipedia.org/wiki/Airplane"));
            params.add(new BasicNameValuePair("page_size", "A4"));
            request.setEntity(new UrlEncodedFormEntity(params));
​
            // Make the POST request.
            HttpClient httpClient = HttpClientBuilder.create().build();
            HttpResponse response = httpClient.execute(request);
            HttpEntity entity = response.getEntity();
            String body = EntityUtils.toString(entity, "UTF-8");
            System.out.println(response.getStatusLine().getStatusCode());
            System.out.println(body);
        } catch (Exception e) {
            System.out.println(e);
        }
    }
}
C# (.NET Core)
using System;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text.Json;
using System.Text.Json.Serialization;
using System.Threading.Tasks;
​
namespace paperplane
{
  class Example
  {
    class Job
    {
      [JsonPropertyName("url")]
      public string Url { get; set; }
​
      // ... add further properties here as required.
    }
    static async Task Main()
    {
      try
      {
        // Grab the API key from the environment.
        string apiKey = Environment.GetEnvironmentVariable("PAPERPLANE_API_KEY");
        if (apiKey is null)
        {
          Console.WriteLine("API key not set");
          return;
        }
​
        // Create a value which will be used for HTTP basic authentication.
        var auth = Convert.ToBase64String(System.Text.Encoding.ASCII.GetBytes(apiKey + ":"));
​
        // Set up a new HTTP client.
        var http = new HttpClient();
        http.BaseAddress = new Uri("https://api.paperplane.app");
        http.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", auth);
​
        // Create a JSON string describing a new job.
        var job = new Job { Url = "https://example.com" };
        var json = JsonSerializer.Serialize(job);
​
        // Post to the jobs endpoint.
        var request = new HttpRequestMessage(HttpMethod.Post, "/jobs");
        request.Content = new StringContent(json, System.Text.Encoding.UTF8, "application/json");
        var response = await http.SendAsync(request);
        var body = await response.Content.ReadAsStringAsync();
        Console.WriteLine("Response status code: {0}", response.StatusCode);
        Console.WriteLine(body);
      }
      catch (HttpRequestException e)
      {
        Console.WriteLine("Exception: {0} ", e.Message);
      }
    }
  }
}
Go
This snippet creates creates a new PDF job. It reads the API key from the PAPERPLANE_API_KEY environment variable, so make sure you have that configured.
package main
​
import (
	"fmt"
	"io/ioutil"
	"log"
	"net/http"
	"net/url"
	"os"
	"strings"
)
​
func main() {
	apiKey := os.Getenv("PAPERPLANE_API_KEY")
	endpoint := "https://api.paperplane.app/jobs"
	formData := url.Values{
		"url":       {"https://en.wikipedia.org/wiki/Airplane"},
		"page_size": {"A4"},
	}.Encode()
​
	// Construct the request
	req, err := http.NewRequest("POST", endpoint, strings.NewReader(formData))
	if err != nil {
		log.Fatal(err)
	}
	req.SetBasicAuth(apiKey, "")
	req.Header.Add("Content-Type", "application/x-www-form-urlencoded")
​
	// Send the request
	client := http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println("response status:", resp.Status)
	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		return
	}
	fmt.Println(string(body))
}
Other languages
We will gradually be adding examples for other languages here. If there’s a specific language you’d like an example for, please get in touch and let us know.
Guide: Serving PDFs to users from Amazon S3
Rendering environment info
Last modified 2yr ago
Copy link
On this page
Ruby (using standard library)
Ruby (using the HTTP gem)
Python
PHP
Node.js
Java
C# (.NET Core)
Other languages