Obter PDF do Boleto

Recupera o PDF do boleto com os dados originais da emissão. Este endpoint retorna o boleto exatamente como foi criado, sem recálculo de encargos por atraso.

Endpoint

GET https://sandbox.boletocloud.com/api/v1/boletos/{token}

Características do PDF Retornado

Dado	Comportamento
Valor	Original (sem recálculo)
Vencimento	Original
Dados do pagador	Atualizados (nome, endereço)
Instruções de cobrança	Originais (incluindo mensagens de desconto)

Nota

A rede bancária aceita o pagamento de boletos vencidos e calcula juros e multa automaticamente no momento do pagamento. Por isso, disponibilizar o PDF original é válido mesmo após o vencimento.

Quando Usar Este Endpoint

Cenário	Recomendação
Disponibilizar 2ª via para o pagador	Sim
Confirmar dados de registro no banco	Sim
Mostrar boleto vencido com valores originais	Sim
Exibir mensagens de desconto do boleto	Sim
Mostrar boleto com encargos calculados	Não (use PDF Atualizado)

Parâmetros

Parâmetro	Tipo	Obrigatório	Descrição
token	string	Sim	Token identificador do boleto (retornado no header X-BoletoCloud-Token na criação)

Headers da Requisição

Header	Valor
Authorization	Basic {credenciais}

Resposta

Código	Content-Type	Descrição
200 OK	application/pdf	PDF do boleto
404 Not Found	application/json	Token não encontrado

Headers da Resposta

Header	Descrição
X-BoletoCloud-Version	Versão da plataforma
Content-Type	application/pdf

Exemplos

cURL

curl -v "https://sandbox.boletocloud.com/api/v1/boletos/{token}" \
  -u "api-key_SUA-API-KEY:token" \
  -o boleto.pdf

Java

import javax.ws.rs.client.ClientBuilder;
import javax.ws.rs.core.Response;
import org.glassfish.jersey.client.authentication.HttpAuthenticationFeature;
import java.io.InputStream;
import java.nio.file.Files;
import java.nio.file.Paths;
import static javax.ws.rs.core.MediaType.WILDCARD;
import static javax.ws.rs.core.Response.Status.OK;
import static java.nio.file.StandardCopyOption.REPLACE_EXISTING;

public class BuscarBoleto {
    public static void main(String[] args) throws Exception {
        String token = "TOKEN_DO_BOLETO";
        Response response = ClientBuilder.newClient()
            .target("https://sandbox.boletocloud.com/api/v1/boletos")
            .path("/" + token)
            .register(HttpAuthenticationFeature.basic("api-key_SUA-API-KEY", "token"))
            .request(WILDCARD)
            .get();

        if (response.getStatus() == OK.getStatusCode()) {
            Files.copy(response.readEntity(InputStream.class),
                Paths.get("boleto.pdf"), REPLACE_EXISTING);
            System.out.println("PDF salvo com sucesso!");
        } else {
            System.out.println("Erro: " + response.getStatus());
        }
    }
}

Kotlin

import okhttp3.Credentials
import okhttp3.OkHttpClient
import okhttp3.Request
import java.io.File

fun main() {
    val token = "TOKEN_DO_BOLETO"
    val client = OkHttpClient()
    val credential = Credentials.basic("api-key_SUA-API-KEY", "token")

    val request = Request.Builder()
        .url("https://sandbox.boletocloud.com/api/v1/boletos/$token")
        .header("Authorization", credential)
        .build()

    client.newCall(request).execute().use { response ->
        if (response.isSuccessful) {
            File("boleto.pdf").writeBytes(response.body!!.bytes())
            println("PDF salvo com sucesso!")
        } else {
            println("Erro: ${response.code}")
        }
    }
}

C#

using System;
using System.IO;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using System.Threading.Tasks;

class Program {
    static async Task Main(string[] args) {
        var token = "TOKEN_DO_BOLETO";
        using var client = new HttpClient();
        var credentials = Convert.ToBase64String(
            Encoding.ASCII.GetBytes("api-key_SUA-API-KEY:token"));
        client.DefaultRequestHeaders.Authorization =
            new AuthenticationHeaderValue("Basic", credentials);

        var response = await client.GetAsync(
            $"https://sandbox.boletocloud.com/api/v1/boletos/{token}");

        if (response.IsSuccessStatusCode) {
            var pdf = await response.Content.ReadAsByteArrayAsync();
            await File.WriteAllBytesAsync("boleto.pdf", pdf);
            Console.WriteLine("PDF salvo com sucesso!");
        } else {
            Console.WriteLine($"Erro: {(int)response.StatusCode}");
        }
    }
}

Node

const https = require('https');
const fs = require('fs');

const token = 'TOKEN_DO_BOLETO';
const options = {
  hostname: 'sandbox.boletocloud.com',
  path: `/api/v1/boletos/${token}`,
  method: 'GET',
  auth: 'api-key_SUA-API-KEY:token'
};

const req = https.request(options, (res) => {
  if (res.statusCode === 200) {
    const file = fs.createWriteStream('boleto.pdf');
    res.pipe(file);
    file.on('finish', () => console.log('PDF salvo com sucesso!'));
  } else {
    console.log(`Erro: ${res.statusCode}`);
  }
});

req.on('error', (e) => console.error(e));
req.end();

Go

package main

import (
    "fmt"
    "io"
    "net/http"
    "os"
)

func main() {
    token := "TOKEN_DO_BOLETO"
    client := &http.Client{}
    req, _ := http.NewRequest("GET",
        "https://sandbox.boletocloud.com/api/v1/boletos/"+token, nil)
    req.SetBasicAuth("api-key_SUA-API-KEY", "token")

    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    if resp.StatusCode == 200 {
        file, _ := os.Create("boleto.pdf")
        defer file.Close()
        io.Copy(file, resp.Body)
        fmt.Println("PDF salvo com sucesso!")
    } else {
        fmt.Printf("Erro: %d\n", resp.StatusCode)
    }
}

PHP

<?php
$token = 'TOKEN_DO_BOLETO';
$url = "https://sandbox.boletocloud.com/api/v1/boletos/$token";
$api_key = 'api-key_SUA-API-KEY';

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_HTTPAUTH, CURLAUTH_BASIC);
curl_setopt($ch, CURLOPT_USERPWD, "$api_key:token");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

$response = curl_exec($ch);
$http_code = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

if ($http_code == 200) {
    file_put_contents('boleto.pdf', $response);
    echo "PDF salvo com sucesso!\n";
} else {
    echo "Erro: $http_code\n";
}
?>

Python

import requests
from requests.auth import HTTPBasicAuth

token = 'TOKEN_DO_BOLETO'
response = requests.get(
    f'https://sandbox.boletocloud.com/api/v1/boletos/{token}',
    auth=HTTPBasicAuth('api-key_SUA-API-KEY', 'token')
)

if response.status_code == 200:
    with open('boleto.pdf', 'wb') as f:
        f.write(response.content)
    print('PDF salvo com sucesso!')
else:
    print(f'Erro: {response.status_code}')

Ruby

require 'net/http'
require 'uri'

token = 'TOKEN_DO_BOLETO'
uri = URI("https://sandbox.boletocloud.com/api/v1/boletos/#{token}")

Net::HTTP.start(uri.host, uri.port, use_ssl: true) do |http|
  request = Net::HTTP::Get.new(uri)
  request.basic_auth('api-key_SUA-API-KEY', 'token')

  response = http.request(request)
  if response.code == '200'
    File.write('boleto.pdf', response.body)
    puts 'PDF salvo com sucesso!'
  else
    puts "Erro: #{response.code}"
  end
end

Clojure

(require '[clj-http.client :as client])

(let [token "TOKEN_DO_BOLETO"
      response (client/get
                (str "https://sandbox.boletocloud.com/api/v1/boletos/" token)
                {:basic-auth ["api-key_SUA-API-KEY" "token"]
                 :as :byte-array})]
  (if (= 200 (:status response))
    (do
      (clojure.java.io/copy (:body response) (clojure.java.io/file "boleto.pdf"))
      (println "PDF salvo com sucesso!"))
    (println "Erro:" (:status response))))

Segunda Via Online (URL Pública)

Além da API, você pode disponibilizar uma URL pública para que o pagador acesse o boleto diretamente:

https://sandbox.boletocloud.com/boleto/2via/{token}

Esta URL pode ser:

• Enviada por e-mail ao cliente
• Exibida em área logada do seu sistema
• Incluída em notificações (SMS, WhatsApp)

Dica

O token do boleto é retornado no header X-BoletoCloud-Token quando você cria o boleto. Guarde este token para poder recuperar o boleto posteriormente e montar a URL de 2ª via.

Veja Também

Obter PDF AtualizadoBoletos em atraso com encargos calculados

Status do RegistroVerificar se foi registrado no banco

Baixar/Cancelar BoletoCancelar a cobrança do boleto

Criar BoletoCriar novos boletos via API