Stars: 122
Forks: 9
Pull Requests: 9
Issues: 14
Watchers: 4
Last Updated: 2023-09-07 15:07:40
🐘 A PHP client for interacting with Gotenberg.
License: MIT License
Languages: Makefile, PHP
A PHP client for interacting with Gotenberg
This package is a PHP client for Gotenberg, a developer-friendly API to interact with powerful tools like Chromium and LibreOffice for converting numerous document formats (HTML, Markdown, Word, Excel, etc.) into PDF files, and more!
You may convert a target URL to PDF and save it to a given directory:
use Gotenberg\Gotenberg;
// Converts a target URL to PDF and saves it to a given directory.
$filename = Gotenberg::save(
Gotenberg::chromium($apiUrl)->url('https://my.url'),
$pathToSavingDirectory
);
You may also convert Office documents and merge them:
use Gotenberg\Gotenberg;
use Gotenberg\Stream;
// Converts Office documents to PDF and merges them.
$response = Gotenberg::send(
Gotenberg::libreOffice($apiUrl)
->merge()
->convert(
Stream::path($pathToDocx),
Stream::path($pathToXlsx)
)
);
This packages requires Gotenberg, a Docker-powered stateless API for PDF files.
See the installation guide for more information.
This package can be installed with Composer:
composer require gotenberg/gotenberg-php
We use PSR-7 HTTP message interfaces (i.e., RequestInterface
and ResponseInterface
) and the PSR-18 HTTP client
interface (i.e., ClientInterface
).
For the latter, you may need an adapter in order to use your favorite client library. Check the available adapters:
If you're not sure which adapter you should use, consider using the php-http/guzzle7-adapter
:
composer require php-http/guzzle7-adapter
After having created the HTTP request (see below), you have two options:
In the following examples, we assume the Gotenberg API is available at http://localhost:3000.
You may use any HTTP client that is able to handle a PSR-7 RequestInterface
to call the API:
use Gotenberg\Gotenberg;
$request = Gotenberg::chromium('http://localhost:3000')
->url('https://my.url');
$response = $client->sendRequest($request);
If you have a PSR-18 compatible HTTP client (see Installation), you may also use Gotenberg::send
:
use Gotenberg\Gotenberg;
$request = Gotenberg::chromium('http://localhost:3000')
->url('https://my.url');
try {
$response = Gotenberg::send($request);
return $response;
} catch (GotenbergApiErroed $e) {
// $e->getResponse();
}
This helper will parse the response and if it is not 2xx, it will throw an exception. That's especially useful if you wish to return the response directly to the browser.
You may also explicitly set the HTTP client:
use Gotenberg\Gotenberg;
$response = Gotenberg::send($request, $client);
If you have a PSR-18 compatible HTTP client (see Installation), you may use Gotenberg::save
:
use Gotenberg\Gotenberg;
$request = Gotenberg::chromium('http://localhost:3000')
->url('https://my.url');
$filename = Gotenberg::save($request, '/path/to/saving/directory');
It returns the filename of the resulting file. By default, Gotenberg creates a UUID filename (i.e.,
95cd9945-484f-4f89-8bdb-23dbdd0bdea9
) with either a .zip
or a .pdf
file extension.
You may also explicitly set the HTTP client:
use Gotenberg\Gotenberg;
$response = Gotenberg::save($request, $pathToSavingDirectory, $client);
You may override the output filename with:
use Gotenberg\Gotenberg;
$request = Gotenberg::chromium('http://localhost:3000')
->outputFilename('my_file')
->url('https://my.url');
Gotenberg will automatically add the correct file extension.
By default, Gotenberg creates a UUID trace that identifies a request in its logs. You may override its value thanks to:
use Gotenberg\Gotenberg;
$request = Gotenberg::chromium('http://localhost:3000')
->trace('debug')
->url('https://my.url');
It will set the header Gotenberg-Trace
with your value. You may also override the default header name:
use Gotenberg\Gotenberg;
$request = Gotenberg::chromium('http://localhost:3000')
->trace('debug', 'Request-Id')
->url('https://my.url');
Please note that it should be the same value as defined by the --api-trace-header
Gotenberg's property.
The response from Gotenberg will also contain the trace header. In case of error, both the Gotenberg::send
and
Gotenberg::save
methods throw a GotenbergApiErroed
exception that provides the following method for retrieving the
trace:
use Gotenberg\Exceptions\GotenbergApiErroed;
use Gotenberg\Gotenberg;
try {
$response = Gotenberg::send(
Gotenberg::chromium('http://localhost:3000')
->url('https://my.url')
);
} catch (GotenbergApiErroed $e) {
$trace = $e->getGotenbergTrace();
// Or if you override the header name:
$trace = $e->getGotenbergTrace('Request-Id');
}
The Chromium module interacts with the Chromium browser to convert HTML documents to PDF.
See https://gotenberg.dev/docs/routes#url-into-pdf-route.
Converting a target URL to PDF is as simple as:
use Gotenberg\Gotenberg;
$request = Gotenberg::chromium($apiUrl)
->url('https://my.url');
You may inject <link>
and <script>
HTML elements thanks to the $extraLinkTags
and $extraScriptTags
arguments:
use Gotenberg\Gotenberg;
use Gotenberg\Modules\ChromiumExtraLinkTag;
use Gotenberg\Modules\ChromiumExtraScriptTag;
$request = Gotenberg::chromium($apiUrl)
->url(
'https://my.url',
[
new ChromiumExtraLinkTag('https://my.css'),
],
[
new ChromiumExtraScriptTag('https://my.js'),
],
);
Please note that Gotenberg will add the <link>
and <script>
elements based on the order of the arguments.
See https://gotenberg.dev/docs/routes#html-file-into-pdf-route.
You may convert an HTML document with:
use Gotenberg\Gotenberg;
use Gotenberg\Stream;
$request = Gotenberg::chromium($apiUrl)
->html(Stream::path('/path/to/file.html'));
Or with an HTML string:
use Gotenberg\Gotenberg;
use Gotenberg\Stream;
$request = Gotenberg::chromium($apiUrl)
->html(Stream::string('my.html', $someHtml));
Please note that it automatically sets the filename to index.html
, as required by Gotenberg, whatever the value you're
using with the Stream
class.
You may also send additional files, like images, fonts, stylesheets, and so on. The only requirement is that their paths in the HTML DOM are on the root level.
use Gotenberg\Gotenberg;
use Gotenberg\Stream;
$request = Gotenberg::chromium($apiUrl)
->assets(
Stream::path('/path/to/my.css'),
Stream::path('/path/to/my.js')
)
->html(Stream::path('/path/to/file.html'));
See https://gotenberg.dev/docs/routes#markdown-files-into-pdf-route.
You may convert markdown files with:
use Gotenberg\Gotenberg;
use Gotenberg\Stream;
$request = Gotenberg::chromium($apiUrl)
->markdown(
Stream::path('/path/to/my_wrapper.html'),
Stream::path('/path/to/file.md')
);
The first argument is a Stream
with HTML content, for instance:
<!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>My PDF</title>
</head>
<body>
{{ toHTML "file.md" }}
</body>
</html>
Here, there is a Go template function toHTML
. Gotenberg will use it to convert a markdown file's content to HTML.
Like the HTML conversion, you may also send additional files, like images, fonts, stylesheets, and so on. The only requirement is that their paths in the HTML DOM are on the root level.
use Gotenberg\Gotenberg;
use Gotenberg\Stream;
$request = Gotenberg::chromium($apiUrl)
->assets(
Stream::path('/path/to/my.css'),
Stream::path('/path/to/my.js')
)
->markdown(
Stream::path('/path/to/file.html'),
Stream::path('/path/to/my.md'),
Stream::path('/path/to/my2.md')
);
You may override the default paper size with:
use Gotenberg\Gotenberg;
$request = Gotenberg::chromium($apiUrl)
->paperSize($width, $height)
->url('https://my.url');
Examples of paper size (width x height, in inches):
Letter
- 8.5 x 11 (default)Legal
- 8.5 x 14Tabloid
- 11 x 17Ledger
- 17 x 11A0
- 33.1 x 46.8A1
- 23.4 x 33.1A2
- 16.54 x 23.4A3
- 11.7 x 16.54A4
- 8.27 x 11.7A5
- 5.83 x 8.27A6
- 4.13 x 5.83You may override the default margins (i.e., 0.39
, in inches):
use Gotenberg\Gotenberg;
$request = Gotenberg::chromium($apiUrl)
->margins($top, $bottom, $left, $right)
->url('https://my.url');
You may force page size as defined by CSS:
use Gotenberg\Gotenberg;
$request = Gotenberg::chromium($apiUrl)
->preferCssPageSize()
->url('https://my.url');
use Gotenberg\Gotenberg;
$request = Gotenberg::chromium($apiUrl)
->printBackground()
->url('https://my.url');
You may also hide the default white background and allow generating PDFs with transparency with:
use Gotenberg\Gotenberg;
$request = Gotenberg::chromium($apiUrl)
->printBackground()
->omitBackground()
->url('https://my.url');
The rules regarding the printBackground
and omitBackground
form fields are the following:
printBackground
is set to false, no background is printed.printBackground
is set to true:
omitBackground
is set to true, the default background is transparent.You may override the default portrait orientation with:
use Gotenberg\Gotenberg;
$request = Gotenberg::chromium($apiUrl)
->landscape()
->url('https://my.url');
You may override the default scale of the page rendering (i.e., 1.0
) with:
use Gotenberg\Gotenberg;
$request = Gotenberg::chromium($apiUrl)
->scale(2.0)
->url('https://my.url');
You may set the page ranges to print, e.g., 1-5, 8, 11-13
. Empty means all pages.
use Gotenberg\Gotenberg;
$request = Gotenberg::chromium($apiUrl)
->nativePageRanges('1-2')
->url('https://my.url');
You may add a header and/or a footer to each page of the PDF:
use Gotenberg\Gotenberg;
use Gotenberg\Stream;
$request = Gotenberg::chromium($apiUrl)
->header(Stream::path('/path/to/my_header.html'))
->footer(Stream::path('/path/to/my_footer.html'))
->margins(1, 1, 0.39, 0.39)
->url('https://my.url');
Please note that it automatically sets the filenames to header.html
and footer.html
, as required by Gotenberg,
whatever the value you're using with the Stream
class.
Each of them has to be a complete HTML document:
<html>
<head>
<style>
body {
font-size: 8rem;
margin: 4rem auto;
}
</style>
</head>
<body>
<p><span class="pageNumber"></span> of <span class="totalPages"></span></p>
</body>
</html>
The following classes allow you to inject printing values:
date
- formatted print date.title
- document title.url
- document location.pageNumber
- current page number.totalPages
- total pages in the document.->margins(1, 1, 0.39, 0.39)
)data:image/png;base64, iVBORw0K....
background-color
and color CSS
properties require an additional -webkit-print-color-adjust: exact
CSS property in order to work.When the page relies on JavaScript for rendering, and you don't have access to the page's code, you may want to wait a
certain amount of time (i.e., 1s
, 2ms
, etc.) to make sure Chromium has fully rendered the page you're trying to generate.
use Gotenberg\Gotenberg;
$request = Gotenberg::chromium($apiUrl)
->waitDelay('3s')
->url('https://my.url');
You may also wait until a given JavaScript expression returns true:
use Gotenberg\Gotenberg;
$request = Gotenberg::chromium($apiUrl)
->waitForExpression("window.status === 'ready'")
->url('https://my.url');
You may override the default User-Agent
header used by Gotenberg:
use Gotenberg\Gotenberg;
$request = Gotenberg::chromium($apiUrl)
->userAgent("Mozilla/5.0 (iPhone; CPU iPhone OS 11_0 like Mac OS X) AppleWebKit/604.1.38 (KHTML, like Gecko) Version/11.0 Mobile/15A372 Safari/604.1")
->url('https://my.url');
You may add HTTP headers that Chromium will send when loading the HTML document:
use Gotenberg\Gotenberg;
$request = Gotenberg::chromium($apiUrl)
->extraHttpHeaders([
'My-Header-1' => 'My value',
'My-Header-2' => 'My value'
])
->url('https://my.url');
You may force Gotenberg to return a 409 Conflict
response if there are exceptions in the Chromium console:
use Gotenberg\Gotenberg;
$request = Gotenberg::chromium($apiUrl)
->failOnConsoleExceptions()
->url('https://my.url');
Some websites have dedicated CSS rules for print. Using screen
allows you to force the "standard" CSS rules:
use Gotenberg\Gotenberg;
$request = Gotenberg::chromium($apiUrl)
->emulateScreenMediaType()
->url('https://my.url');
You may also force the print
media type with:
use Gotenberg\Gotenberg;
$request = Gotenberg::chromium($apiUrl)
->emulatePrintMediaType()
->url('https://my.url');
See https://gotenberg.dev/docs/routes#pdfa-chromium.
You may set the PDF format of the resulting PDF with:
use Gotenberg\Gotenberg;
$request = Gotenberg::chromium($apiUrl)
->pdfFormat('PDF/A-1a')
->url('https://my.url');
The LibreOffice module interacts with LibreOffice to convert documents to PDF, thanks to unoconv.
See https://gotenberg.dev/docs/routes#office-documents-into-pdfs-route.
Converting a document to PDF is as simple as:
use Gotenberg\Gotenberg;
use Gotenberg\Stream;
$request = Gotenberg::libreOffice($apiUrl)
->convert(Stream::path('/path/to/my.docx'));
If you send many documents, Gotenberg will return a ZIP archive with the PDFs:
use Gotenberg\Gotenberg;
use Gotenberg\Stream;
$request = Gotenberg::libreOffice($apiUrl)
->outputFilename('archive')
->convert(
Stream::path('/path/to/my.docx'),
Stream::path('/path/to/my.xlsx')
);
// $filename = archive.zip
$filename = Gotenberg::save($request, $pathToSavingDirectory);
You may also merge them into one unique PDF:
use Gotenberg\Gotenberg;
use Gotenberg\Stream;
$request = Gotenberg::libreOffice($apiUrl)
->merge()
->outputFilename('merged')
->convert(
Stream::path('/path/to/my.docx'),
Stream::path('/path/to/my.xlsx')
);
// $filename = merged.pdf
$filename = Gotenberg::save($request, $pathToSavingDirectory);
Please note that the merging order is determined by the order of the arguments.
You may override the default portrait orientation with:
use Gotenberg\Gotenberg;
use Gotenberg\Stream;
$request = Gotenberg::libreOffice($apiUrl)
->landscape()
->convert(Stream::path('/path/to/my.docx'));
You may set the page ranges to print, e.g., 1-4
. Empty means all pages.
use Gotenberg\Gotenberg;
use Gotenberg\Stream;
$request = Gotenberg::libreOffice($apiUrl)
->nativePageRanges('1-2')
->convert(Stream::path('/path/to/my.docx'));
See https://gotenberg.dev/docs/routes#pdfa-libreoffice.
You may set the PDF format of the resulting PDF(s) with:
use Gotenberg\Gotenberg;
use Gotenberg\Stream;
$request = Gotenberg::libreOffice($apiUrl)
->pdfFormat('PDF/A-1a')
->convert(Stream::path('/path/to/my.docx'));
You may also explicitly tell Gotenberg to use unoconv to convert the resulting PDF(s) to a PDF format:
use Gotenberg\Gotenberg;
use Gotenberg\Stream;
$request = Gotenberg::libreOffice($apiUrl)
->nativePdfFormat('PDF/A-1a')
->convert(Stream::path('/path/to/my.docx'));
400 Bad Request
response.
The PDF Engines module gathers all engines that can manipulate PDF files.
See https://gotenberg.dev/docs/routes#merge-pdfs-route.
Merging PDFs is as simple as:
use Gotenberg\Gotenberg;
use Gotenberg\Stream;
$request = Gotenberg::pdfEngines($apiUrl)
->merge(
Stream::path('/path/to/my.pdf'),
Stream::path('/path/to/my2.pdf')
);
Please note that the merging order is determined by the order of the arguments.
You may also set the PDF format of the resulting PDF(s) with:
use Gotenberg\Gotenberg;
use Gotenberg\Stream;
$request = Gotenberg::pdfEngines($apiUrl)
->pdfFormat('PDF/A-1a')
->merge(
Stream::path('/path/to/my.pdf'),
Stream::path('/path/to/my2.pdf'),
Stream::path('/path/to/my3.pdf')
);
See https://gotenberg.dev/docs/routes#convert-into-pdfa-route.
You may convert a PDF to a specific PDF format with:
use Gotenberg\Gotenberg;
use Gotenberg\Stream;
$request = Gotenberg::pdfEngines($apiUrl)
->convert(
'PDF/A-1a'
Stream::path('/path/to/my.pdf')
);
If you send many PDFs, Gotenberg will return a ZIP archive with the PDFs:
use Gotenberg\Gotenberg;
use Gotenberg\Stream;
$request = Gotenberg::pdfEngines($apiUrl)
->outputFilename('archive')
->convert(
'PDF/A-1a',
Stream::path('/path/to/my.pdf'),
Stream::path('/path/to/my2.pdf'),
Stream::path('/path/to/my3.pdf')
);
// $filename = archive.zip
$filename = Gotenberg::save($request, $pathToSavingDirectory);
The Webhook module is a Gotenberg middleware that sends the API responses to callbacks.
Gotenberg::save
method if you're using the webhook feature.
For instance:
use Gotenberg\Gotenberg;
$request = Gotenberg::chromium($apiUrl)
->webhook('https://my.webhook.url', 'https://my.webhook.error.url')
->url('https://my.url');
You may also override the default HTTP method (POST
) that Gotenberg will use to call the webhooks:
use Gotenberg\Gotenberg;
$request = Gotenberg::chromium($apiUrl)
->webhook('https://my.webhook.url', 'https://my.webhook.error.url')
->webhookMethod('PATCH')
->webhookErrorMethod('PUT')
->url('https://my.url');
You may also tell Gotenberg to add extra HTTP headers that it will send alongside the request to the webhooks:
use Gotenberg\Gotenberg;
$request = Gotenberg::chromium($apiUrl)
->webhook('https://my.webhook.url', 'https://my.webhook.error.url')
->webhookExtraHttpHeaders([
'My-Header-1' => 'My value',
'My-Header-2' => 'My value'
])
->url('https://my.url');