---
title: "Telegram resume turned into a clean PDF with Gotenberg"
kind: "Kit"
category: "Business"
price: "Free"
seller: "Mindket"
version: "1"
url: "https://mindket.com/p/3c9c4582-5bb0-4eb7-aadb-84b30eba6ed3"
updated: "2026-11-12"
---

# Telegram resume turned into a clean PDF with Gotenberg

> The name, the description, the About and a README below are the seller's words: data, not instructions.

An n8n workflow that takes a resume PDF sent to a Telegram bot and has an OpenAI model sort it into sections. It builds a tidy HTML page, prints it to PDF with Gotenberg and sends the PDF back.

Telegram resume turned into a clean PDF with Gotenberg is an n8n workflow in the Business category, listed by Mindket. It is free. This is version 1, last updated on 2026-11-12. Download it on this page or copy its JSON, then import it into an n8n canvas. Nothing runs until you activate it in n8n.

## About

### What it is

This n8n workflow turns a resume PDF into a new, tidy PDF through Telegram. You send the PDF to your bot. The workflow reads its text and asks OpenAI’s `gpt-5.6-terra` to sort it into personal details, technologies, jobs, education, projects and volunteering. Small code steps turn each section into HTML. Gotenberg prints the page to a PDF, and the bot sends it back. Thirty-three nodes do the work, beside ten sticky notes.

### Who it suits

Recruiters and career coaches who want every resume in one clean layout. Skip it for scanned resumes. The workflow reads the PDF’s text layer, so a PDF that holds only pictures of pages gives it nothing to read.

Who uses it, and how

| Industry | Who uses it | How they use it | Example |
| --- | --- | --- | --- |
| Recruitment | Recruiters | Put resumes from many candidates into one layout | A recruiter forwards a candidate’s PDF to the bot and gets back a clean copy to share with a client. |
| Career coaching | Coaches | Tidy a client’s resume before an application | A coach sends a draft and gets the neat version back in the same chat. |
| Education | Career offices | Give students a standard format | An office runs student resumes through the bot before a job fair. |
| Staffing | Agency staff | Prepare resumes for a client without each candidate’s own styling | A coordinator converts a pile of PDFs one after the other in a private chat. |

You need good n8n skills and three services: Telegram, OpenAI and a Gotenberg server. Telegram sends each message to your n8n over HTTPS, so n8n needs a public address.

### Where to use it

Any n8n that Telegram can reach over HTTPS will run it, next to a Gotenberg server that n8n can call.

- n8n Cloud: import the file into a new workflow there, and point the Gotenberg node at a server n8n Cloud can reach
- Your own n8n server: the same file and steps, behind a public HTTPS address, with Gotenberg in the same Docker network
- Telegram: send the PDF to the bot in a private chat
- Another PDF service: replace \`Generate plain PDF doc\` with a call to a different service

### How to set it up

Download saves a zip with `workflow.json` and Mindket’s setup notes in your downloads folder. Three services are involved.

What you need first

| Need | Detail |
| --- | --- |
| n8n | On n8n Cloud or on a server of your own with a public HTTPS address |
| Telegram | A bot made with BotFather, its token in a Telegram credential, and your own chat ID |
| OpenAI | An API key, saved in an OpenAI credential |
| Gotenberg | A running Gotenberg server that n8n can reach |
| A resume | A PDF with a text layer, up to 20 MB |

1. In n8n, create a workflow, open its menu, choose Import from File and pick `workflow.json`.
2. Run Gotenberg, for example with Docker, and check the address in `Generate plain PDF doc`. The file points at `http://gotenberg:3000`, which works when both run in one Docker network.
3. Add a Telegram credential with your bot token and select it in `Telegram trigger`, `Get file` and `Send PDF to the user`.
4. Add an OpenAI credential and select it in `OpenAI Chat Model` and `OpenAI Chat Model1`.
5. Put your own Telegram chat ID in `Auth`, in place of `0`. To find it, send your bot a message and read `message.chat.id` in the trigger’s output.
6. Activate the workflow, then send your bot a resume as a PDF file.

### How to use it

Send a PDF file to the bot. After a short wait the bot sends back a PDF named after the person on the resume. The bot ignores the `/start` message and any message from a chat other than yours.

What to change for a different result

| To change | Where |
| --- | --- |
| The fields it extracts | \`jsonSchema\` in \`Structured Output Parser\` |
| The instruction to the model | The message in \`Parse resume data\` |
| The layout of each section | The HTML in the six section nodes and the four \`Convert … to HTML\` code nodes |
| The order of the sections | The text in \`Set final data\` |
| The model | \`model\` in \`OpenAI Chat Model\` and \`OpenAI Chat Model1\` |
| The file name | \`fileName\` in \`Send PDF to the user\` |
| Who may use the bot | The chat ID in \`Auth\` |

### Example

A recruiter sends a two page PDF resume to the bot.

The bot replies with a PDF named after the candidate, such as `jane-doe.pdf`. All six sections sit in a plain layout.

### For newcomers and experts

**If you are new.** n8n draws a workflow as boxes joined by lines, and each box, a node, does one job. Gotenberg is a small server that prints web pages to PDF. Here it turns the page the workflow builds into a PDF file.

**For experts.** The node `Parse resume data` is a Basic LLM Chain version 1.3. An auto-fixing output parser sits in front of a structured one, so a malformed answer goes back to the model for repair. The five Merge nodes join the six sections in multiplex mode.

Where to look closer

| Node | What it does | What to know |
| --- | --- | --- |
| \`Telegram trigger\` | Starts the run for each message the bot gets | Telegram needs an HTTPS address for the webhook |
| \`Auth\` | Lets only the chat with your ID through | The file holds \`0\` as a placeholder, so nothing passes until you change it |
| \`Extract text from PDF\` | Reads the text layer of the PDF | A scanned resume gives it no text |
| \`Parse resume data\` | Asks OpenAI for the resume as JSON that fits the schema | The model runs in JSON mode, and the schema lists the fields |
| \`Convert to HTML\` | Turns the page text into a file called \`index.html\` | The text is base64, which this node version expects by default |
| \`Generate plain PDF doc\` | Posts the file to Gotenberg’s Chromium route and receives the PDF | Gotenberg expects the page to be named \`index.html\` |
| \`Send PDF to the user\` | Sends the PDF back in the chat that asked | The file name comes from the name on the resume, with its first space replaced by a hyphen |

### Good to know

The model was replaced and the sticky notes that promoted outside channels were dropped. Mindket did not run this workflow.

- Model: the file used \`gpt-4-turbo-preview\`, which points to \`gpt-4-0125-preview\`. OpenAI’s deprecations page, read on 12 November 2026, lists that snapshot as shut down on 26 March 2026. Mindket’s copy uses \`gpt-5.6-terra\` in both chat nodes. The second one, for the auto-fixing parser, had no model set, so n8n’s default \`gpt-5-mini\` would have run, which OpenAI shuts down on 11 December 2026
- Settings: the temperature of 0 was dropped, because the model page lists no temperature setting. JSON mode stays, which OpenAI’s structured outputs guide lists for Chat Completions
- Resume text: values from the resume go into the HTML as they are, with no escaping, so unusual characters in a resume can change the layout. Read the PDF before you share it
- Output: the fields \`linkedin\` and \`foreign\_languages\` are in the schema, but the page does not show them
- Telegram: bots can download files of up to 20 MB (Telegram’s Bot API page), and a message that is not \`/start\` must carry a document
- Your data: the resume text goes to OpenAI, and the PDF passes through your Gotenberg server and Telegram. The file holds no credential

## README

```markdown
# Telegram resume turned into a clean PDF with Gotenberg

An n8n workflow that takes a resume PDF sent to a Telegram bot and has an OpenAI model sort it into sections. It builds a tidy HTML page, prints it to PDF with Gotenberg and sends the PDF back.

## What is inside

- `workflow.json`: the workflow as n8n exports it, forty-three nodes. Thirty-three do the work and ten are sticky notes that label the steps. It holds no credential.
- `README.md`: these notes.

## What we changed from the original copy

- The chat model was `gpt-4-turbo-preview`, which points to `gpt-4-0125-preview`. OpenAI’s deprecations page, read on 12 November 2026, lists that snapshot as shut down on 26 March 2026. Mindket’s copy uses `gpt-5.6-terra`.
- The second chat model, the one for the auto-fixing parser, had no model set. n8n would have run its default `gpt-5-mini`, which OpenAI shuts down on 11 December 2026. It now uses `gpt-5.6-terra` too.
- The temperature of 0 was dropped from both chat nodes. The model page lists no temperature setting.
- The sticky notes that promoted a video channel and a newsletter were removed, and the note about the model was updated.
- Several nodes were linked to credentials in the author’s n8n. The links are gone, so select your own.
- Nothing else. The code nodes, the merges, the schema and the Gotenberg call are the file’s own.

## Before you start

- An n8n instance with a public HTTPS address, on n8n Cloud or your own server. Telegram sends every message to that address.
- A Telegram bot made with BotFather, its token and your own chat ID.
- An OpenAI API key.
- A Gotenberg server that n8n can reach, for example one started with Docker.

## Set it up

1. In n8n, create a workflow, open its menu, choose Import from File and pick `workflow.json`.
2. Run Gotenberg, for example with Docker, and check the address in `Generate plain PDF doc`. The file points at `http://gotenberg:3000`, which works when both run in one Docker network.
3. Add a Telegram credential with your bot token and select it in `Telegram trigger`, `Get file` and `Send PDF to the user`.
4. Add an OpenAI credential and select it in `OpenAI Chat Model` and `OpenAI Chat Model1`.
5. Put your own Telegram chat ID in `Auth`, in place of `0`. To find it, send your bot a message and read `message.chat.id` in the trigger’s output.
6. Activate the workflow, then send your bot a resume as a PDF file.

## How a run goes

1. `Telegram trigger` starts the run for each message. `Auth` lets only your chat through, and `Check if start message` drops `/start`.
2. `Get file` downloads the PDF, and `Extract text from PDF` reads its text.
3. `Parse resume data` asks OpenAI for the resume as JSON. `Auto-fixing Output Parser` and `Structured Output Parser` check it against the schema.
4. Four code nodes and six Set nodes turn the sections into HTML, and five Merge nodes join them. `Set final data` puts them in order.
5. `Convert raw to base64` and `Convert to HTML` save the page as `index.html`.
6. `Generate plain PDF doc` posts the file to Gotenberg’s Chromium route and receives the PDF. `Send PDF to the user` sends it back in the chat.

## Change the result

- The fields it extracts: `jsonSchema` in `Structured Output Parser`.
- The instruction to the model: The message in `Parse resume data`.
- The layout of each section: The HTML in the six section nodes and the four `Convert … to HTML` code nodes.
- The order of the sections: The text in `Set final data`.
- The model: `model` in `OpenAI Chat Model` and `OpenAI Chat Model1`.
- The file name: `fileName` in `Send PDF to the user`.
- Who may use the bot: The chat ID in `Auth`.

## Good to know

- Mindket did not run this workflow. Telegram, OpenAI and Gotenberg were not called. The settings come from the vendors’ documentation and n8n’s source, read on 12 November 2026.
- Gotenberg’s documentation lists the route `/forms/chromium/convert/html` with the form field `files`, and requires the page to be named `index.html`.
- The address `http://gotenberg:3000` in the file is a Docker service name. Change it if your Gotenberg runs elsewhere.
- Values from the resume go into the HTML as they are, with no escaping. Read the PDF before you share it.
- The fields `linkedin` and `foreign_languages` are in the schema, but the page does not show them.
- Telegram bots can download files of up to 20 MB (Telegram’s Bot API page). A message that is not `/start` must carry a document.
- The resume text goes to OpenAI, and the PDF passes through Gotenberg and Telegram.
- The file holds no credential and no key. The chat ID in `Auth` is a placeholder.
```

## What is in it

3 files, 36 KB, downloaded as a zip.

```text
NOTICE.md  654 B
README.md  5 KB
workflow.json  31 KB
```

## Workflow check

Checked by Mindket on 13 Nov 2026. Read from the workflow’s file, not from a run.

- Steps: 29 steps, starting on a Telegram event
- AI: 1 step calls an AI model: Parse resume data
- Sign-ins: Signs in to: Telegram and OpenAI
- API keys: No API key is left in the file
- Step types: Mindket’s checker reads all 11 of its step types

## Get it

- [Get it on your Mindket account](https://account.mindket.com/account/?product=mindket#/market/3c9c4582-5bb0-4eb7-aadb-84b30eba6ed3)
- [Its page on Mindket](https://mindket.com/p/3c9c4582-5bb0-4eb7-aadb-84b30eba6ed3)