How to Convert HTML to Text in Make.com (and Extract Text From Any URL)

Make.com's HTML to text module lives in the Text parser app. Add a Text parser module to your scenario, choose HTML to text, and map your HTML into it. It converts the HTML into formatted text you can pass to the next module. For a quick inline conversion, Make also has a built-in stripHTML() function you can use in any mapped field.

Those tools work on HTML you already have. If you're starting from a URL, especially a JavaScript-heavy or protected page, you'll get better results by calling a URL to text API from Make's HTTP module. This guide covers both.

Option 1: Make's built-in HTML to text module

The Text parser app includes several transformers for working with HTML and text. The ones people usually mean when searching for a "Make.com HTML extract module" are:

Module	What it does
HTML to text	Converts HTML to formatted text
Get elements from HTML	Pulls specific elements out of HTML: images, links, or iframes (Make docs)
Match pattern	Extracts text that matches a regular expression
Replace	Finds and replaces text with a pattern

Steps: fetch a page and convert it to text

Add an HTTP module. Search for HTTP and choose Make a request. Set Method to GET and enter the page URL in URL. Make's HTTP module only accepts https:// URLs (Make docs).
Add the Text parser module. Click the plus after the HTTP module, search for Text parser, and choose HTML to text.
Map the HTML. In the HTML to text module, map the response body (the Data item) from the HTTP module into the HTML input.
Run once with Run once at the bottom of the editor and check the output bundle. The converted text is now available to map into later modules.

Extracting links from HTML in Make

To get all the links on a page instead of the text, use Get elements from HTML and set Element type to links. It also supports images and iframes. It doesn't support other elements like paragraphs or headings, so to pull out a specific section you'd use Match pattern with a regex instead.

Using stripHTML() instead of a module

If you just need to clean up a field, such as an email body or a CMS description, you don't need a separate module. Open the field's mapping panel and wrap the value in Make's stripHTML() function. Make community answers also recommend wrapping non-text input in toString() first, as in stripHTML(toString(1.data)) (Make Community). That saves an operation per run compared to adding a module.

Where the built-in module falls short

The HTML to text module only converts the HTML it receives. That causes three common problems:

JavaScript-rendered pages come back nearly empty. Make's HTTP module downloads the page's starting HTML and doesn't run JavaScript. On sites built with frameworks like Next.js or React, the text loads later in the browser, so the module may output only the page title. Make Community members report exactly this and recommend a third-party service for such sites (Make Community).
The whole page comes along. Menus, footers, cookie notices, and sidebars all get converted. Trimming them with regex is fragile.
Formatting is limited. Users report that lists and layout don't always come through cleanly, and there's no Markdown output, which is what most AI modules work best with.

Some sites also block requests that don't come from a normal browser, so the HTTP module gets an error page instead of content.

Option 2: Extract text from any URL with the URLtoText API

The URLtoText API takes a URL and returns the page's text, Markdown, or HTML as JSON. It can render JavaScript, route requests through residential or stealth proxies, and limit extraction to one part of the page with a CSS selector. In Make, you call it with the HTTP module, so you don't need a custom app.

Step 1: Get an API token

Sign up at urltotext.com, buy credits, and copy your API token from your account. A basic request costs $0.00015. JavaScript rendering, proxies, and AI prompts cost extra, so turn them on only for pages that need them.

Step 2: Add an HTTP "Make a request" module

Configure it like this:

Field	Value
URL	`https://urltotext.com/api/v1/urltotext/`
Method	`POST`
Headers	Name: `Authorization`, Value: `Token YOUR_API_TOKEN`
Body content type	`application/json`
Body input method	JSON string
Parse response	Yes

Under the advanced settings, set Timeout to a higher value, such as 120 seconds, since rendering JavaScript takes longer than a plain fetch (Make allows 1 to 300 seconds). Set Return error if HTTP request fails to Yes so the scenario stops on a bad request instead of passing empty data along.

Step 3: Write the JSON body

Paste this into the body field, and map your URL in place of the example. The URL usually comes from an earlier module, like a Google Sheets row, an RSS item, or a webhook.

{
  "url": "https://example.com/blog/some-article",
  "output_format": "markdown",
  "render_javascript": true,
  "wait_for_js": 2000,
  "extract_css_selector": "article"
}

What each field does:

output_format: "text", "markdown", or "html". Use Markdown if the next step is an AI module.
render_javascript: load the page in a browser first. Turn this on for JavaScript-heavy sites.
wait_for_js: milliseconds to wait after the page loads, for content that appears late.
extract_css_selector: keep only the matching element, such as article or .post-content.
end_of_article: optional text that marks the end of the content, such as "Related posts". Extraction stops there.
residential_proxy or stealth_proxy: set to true for sites that block ordinary requests.
ai_prompt: optional instruction to run on the extracted content, such as "Summarize in three bullet points."

URLtoText doesn't remove ads or boilerplate automatically. The CSS selector and end-of-article options are how you narrow the output to the content you want.

If you choose JSON string as the input method, Make won't escape reserved characters in mapped values for you. A URL rarely contains quotes, but if you map other text (like an AI prompt from a sheet), use the Data structure input method instead, which escapes values automatically (Make docs).

Step 4: Map data.content into the next module

Run the module once. The parsed response looks like this:

{
  "message": "Request processed successfully",
  "data": {
    "url": "https://example.com/blog/some-article",
    "page_title": "Some Article",
    "published_date": null,
    "og_image_url": "https://example.com/images/some-article.png",
    "og_description": "A short summary of the article.",
    "output_format": "markdown",
    "content": "# Some Article\n\nThe article text..."
  },
  "credits_used": 0.00075
}

In the next module's mapping panel, open the HTTP module's Data output, then data, and pick content. page_title and og_description are useful too.

Example scenario: URLs in Google Sheets to summaries

A common setup looks like this:

Google Sheets: Search Rows (or Watch New Rows) to get rows that have a URL and an empty summary column.
HTTP: Make a request to the URLtoText API, with the row's URL mapped into the JSON body.
An AI module (OpenAI, Anthropic Claude, or another provider) with a prompt like "Summarize this article in three sentences," and data.content mapped into the message.
Google Sheets: Update a Row to write the page title and summary back to the sheet.

If you only need a short summary, you can skip step 3 and use the API's ai_prompt field instead. The summary then comes back in the same response.

When to use which

Situation	Use
You already have HTML (emails, CMS fields, webhook payloads)	`stripHTML()` or the HTML to text module
You need the links or images from HTML	Get elements from HTML
Simple static page, and the whole page's text is fine	HTTP GET + HTML to text
JavaScript-rendered page that comes back empty	URLtoText API with `render_javascript`
Site blocks Make's requests	URLtoText API with a residential or stealth proxy
You want Markdown for an AI module, or only the article body	URLtoText API with `output_format` and `extract_css_selector`

The built-in module is free beyond Make's own operation cost, so start there for simple jobs. Switch to an API when pages come back empty, blocked, or full of clutter. For more on that tradeoff, see web scraping vs. API.