# URL to Markdown

## Table of Contents

- [CLI Microlink API example](#cli-microlink-api-example)
  - [cURL Microlink API example](#curl-microlink-api-example)
  - [JavaScript Microlink API example](#javascript-microlink-api-example)
  - [Python Microlink API example](#python-microlink-api-example)
  - [Ruby Microlink API example](#ruby-microlink-api-example)
  - [PHP Microlink API example](#php-microlink-api-example)
  - [Golang Microlink API example](#golang-microlink-api-example)
- [Any source URL works the same way](#any-source-url-works-the-same-way)
  - [CLI Microlink API example](#cli-microlink-api-example-1)
  - [cURL Microlink API example](#curl-microlink-api-example-1)
  - [JavaScript Microlink API example](#javascript-microlink-api-example-1)
  - [Python Microlink API example](#python-microlink-api-example-1)
  - [Ruby Microlink API example](#ruby-microlink-api-example-1)
  - [PHP Microlink API example](#php-microlink-api-example-1)
  - [Golang Microlink API example](#golang-microlink-api-example-1)
- [Return Markdown directly](#return-markdown-directly)
  - [CLI Microlink API example](#cli-microlink-api-example-2)
  - [cURL Microlink API example](#curl-microlink-api-example-2)
  - [JavaScript Microlink API example](#javascript-microlink-api-example-2)
  - [Python Microlink API example](#python-microlink-api-example-2)
  - [Ruby Microlink API example](#ruby-microlink-api-example-2)
  - [PHP Microlink API example](#php-microlink-api-example-2)
  - [Golang Microlink API example](#golang-microlink-api-example-2)
- [Scope noisy pages](#scope-noisy-pages)
  - [CLI Microlink API example](#cli-microlink-api-example-3)
  - [cURL Microlink API example](#curl-microlink-api-example-3)
  - [JavaScript Microlink API example](#javascript-microlink-api-example-3)
  - [Python Microlink API example](#python-microlink-api-example-3)
  - [Ruby Microlink API example](#ruby-microlink-api-example-3)
  - [PHP Microlink API example](#php-microlink-api-example-3)
  - [Golang Microlink API example](#golang-microlink-api-example-3)
- [Keep metadata when useful](#keep-metadata-when-useful)
- [YouTube videos](#youtube-videos)
  - [CLI Microlink API example](#cli-microlink-api-example-4)
  - [cURL Microlink API example](#curl-microlink-api-example-4)
  - [JavaScript Microlink API example](#javascript-microlink-api-example-4)
  - [Python Microlink API example](#python-microlink-api-example-4)
  - [Ruby Microlink API example](#ruby-microlink-api-example-4)
  - [PHP Microlink API example](#php-microlink-api-example-4)
  - [Golang Microlink API example](#golang-microlink-api-example-4)
- [Supported source formats](#supported-source-formats)
- [Next step](#next-step)
- [See also](#see-also)

---

Use [attr](https://microlink.io/docs/sdk/methods/extract/attr) with `markdown` to serialize any URL as Markdown. This is the direct recipe for LLM ingestion, RAG pipelines, docs imports, and any workflow that should not carry raw HTML.

The following examples show how to use the Microlink API with CLI, cURL, JavaScript, Python, Ruby, PHP & Golang, targeting 'https://docs.stripe.com/api' URL with 'data' & 'meta' API parameters:

### CLI Microlink API example

```bash
microlink https://docs.stripe.com/api&data.markdown.attr=markdown
```

### cURL Microlink API example

```bash
curl -G "https://api.microlink.io" \
  -d "url=https://docs.stripe.com/api" \
  -d "data.markdown.attr=markdown" \
  -d "meta=false"
```

### JavaScript Microlink API example

```javascript
import createClient from 'microlink.io'

const microlink = createClient()

const markdown = await microlink.markdown('https://docs.stripe.com/api')
```

### Python Microlink API example

```python
import requests

url = "https://api.microlink.io/"

querystring = {
    "url": "https://docs.stripe.com/api",
    "data.markdown.attr": "markdown",
    "meta": "false"
}

response = requests.get(url, params=querystring)

print(response.json())
```

### Ruby Microlink API example

```ruby
require 'uri'
require 'net/http'

base_url = "https://api.microlink.io/"

params = {
  url: "https://docs.stripe.com/api",
  data.markdown.attr: "markdown",
  meta: "false"
}

uri = URI(base_url)
uri.query = URI.encode_www_form(params)

http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Get.new(uri)
response = http.request(request)

puts response.body
```

### PHP Microlink API example

```php
<?php

$baseUrl = "https://api.microlink.io/";

$params = [
    "url" => "https://docs.stripe.com/api",
    "data.markdown.attr" => "markdown",
    "meta" => "false"
];

$query = http_build_query($params);
$url = $baseUrl . '?' . $query;

$curl = curl_init();

curl_setopt_array($curl, [
    CURLOPT_URL => $url,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_ENCODING => "",
    CURLOPT_MAXREDIRS => 10,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
    CURLOPT_CUSTOMREQUEST => "GET"
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
    echo "cURL Error #: " . $err;
} else {
    echo $response;
}
```

### Golang Microlink API example

```
package main

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

func main() {
    baseURL := "https://api.microlink.io"

    u, err := url.Parse(baseURL)
    if err != nil {
        panic(err)
    }
    q := u.Query()
    q.Set("url", "https://docs.stripe.com/api")
    q.Set("data.markdown.attr", "markdown")
    q.Set("meta", "false")
    u.RawQuery = q.Encode()

    req, err := http.NewRequest("GET", u.String(), nil)
    if err != nil {
        panic(err)
    }

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

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        panic(err)
    }

    fmt.Println(string(body))
}
```

```javascript
importcreateClientfrom'microlink.io'

constmicrolink=createClient()

constmarkdown=awaitmicrolink.markdown('https://docs.stripe.com/api')
```

Read the converted page from `data.markdown`.

## Any source URL works the same way

Point [url](https://microlink.io/docs/api/parameters/url) at a web page, a PDF file, or an office document. Microlink converts a PDF or `docx`/`xlsx`/`pptx` file to an HTML DOM at fetch time, so the same `attr: 'markdown'` request turns it into readable Markdown:

The following examples show how to use the Microlink API with CLI, cURL, JavaScript, Python, Ruby, PHP & Golang, targeting 'https://cdn.microlink.io/file-examples/sample.docx' URL with 'data' & 'meta' API parameters:

### CLI Microlink API example

```bash
microlink https://cdn.microlink.io/file-examples/sample.docx&data.markdown.attr=markdown
```

### cURL Microlink API example

```bash
curl -G "https://api.microlink.io" \
  -d "url=https://cdn.microlink.io/file-examples/sample.docx" \
  -d "data.markdown.attr=markdown" \
  -d "meta=false"
```

### JavaScript Microlink API example

```javascript
import createClient from 'microlink.io'

const microlink = createClient()

const markdown =
  await microlink.markdown('https://cdn.microlink.io/file-examples/sample.docx')
```

### Python Microlink API example

```python
import requests

url = "https://api.microlink.io/"

querystring = {
    "url": "https://cdn.microlink.io/file-examples/sample.docx",
    "data.markdown.attr": "markdown",
    "meta": "false"
}

response = requests.get(url, params=querystring)

print(response.json())
```

### Ruby Microlink API example

```ruby
require 'uri'
require 'net/http'

base_url = "https://api.microlink.io/"

params = {
  url: "https://cdn.microlink.io/file-examples/sample.docx",
  data.markdown.attr: "markdown",
  meta: "false"
}

uri = URI(base_url)
uri.query = URI.encode_www_form(params)

http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Get.new(uri)
response = http.request(request)

puts response.body
```

### PHP Microlink API example

```php
<?php

$baseUrl = "https://api.microlink.io/";

$params = [
    "url" => "https://cdn.microlink.io/file-examples/sample.docx",
    "data.markdown.attr" => "markdown",
    "meta" => "false"
];

$query = http_build_query($params);
$url = $baseUrl . '?' . $query;

$curl = curl_init();

curl_setopt_array($curl, [
    CURLOPT_URL => $url,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_ENCODING => "",
    CURLOPT_MAXREDIRS => 10,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
    CURLOPT_CUSTOMREQUEST => "GET"
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
    echo "cURL Error #: " . $err;
} else {
    echo $response;
}
```

### Golang Microlink API example

```
package main

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

func main() {
    baseURL := "https://api.microlink.io"

    u, err := url.Parse(baseURL)
    if err != nil {
        panic(err)
    }
    q := u.Query()
    q.Set("url", "https://cdn.microlink.io/file-examples/sample.docx")
    q.Set("data.markdown.attr", "markdown")
    q.Set("meta", "false")
    u.RawQuery = q.Encode()

    req, err := http.NewRequest("GET", u.String(), nil)
    if err != nil {
        panic(err)
    }

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

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        panic(err)
    }

    fmt.Println(string(body))
}
```

```javascript
importcreateClientfrom'microlink.io'

constmicrolink=createClient()

constmarkdown=

awaitmicrolink.markdown('https://cdn.microlink.io/file-examples/sample.docx')
```

Swap the URL for a `.pdf`, `.xlsx`, or `.pptx` file and the request is identical.

## Return Markdown directly

Add [embed](https://microlink.io/docs/api/parameters/embed) with `markdown` when the API URL should return Markdown instead of JSON:

The following examples show how to use the Microlink API with CLI, cURL, JavaScript, Python, Ruby, PHP & Golang, targeting 'https://docs.stripe.com/api' URL with 'data', 'meta' & 'embed' API parameters:

### CLI Microlink API example

```bash
microlink https://docs.stripe.com/api&data.markdown.attr=markdown&embed=markdown
```

### cURL Microlink API example

```bash
curl -G "https://api.microlink.io" \
  -d "url=https://docs.stripe.com/api" \
  -d "data.markdown.attr=markdown" \
  -d "meta=false" \
  -d "embed=markdown"
```

### JavaScript Microlink API example

```javascript
import createClient from 'microlink.io'

const microlink = createClient()

const markdown = await microlink.markdown('https://docs.stripe.com/api')
```

### Python Microlink API example

```python
import requests

url = "https://api.microlink.io/"

querystring = {
    "url": "https://docs.stripe.com/api",
    "data.markdown.attr": "markdown",
    "meta": "false",
    "embed": "markdown"
}

response = requests.get(url, params=querystring)

print(response.json())
```

### Ruby Microlink API example

```ruby
require 'uri'
require 'net/http'

base_url = "https://api.microlink.io/"

params = {
  url: "https://docs.stripe.com/api",
  data.markdown.attr: "markdown",
  meta: "false",
  embed: "markdown"
}

uri = URI(base_url)
uri.query = URI.encode_www_form(params)

http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Get.new(uri)
response = http.request(request)

puts response.body
```

### PHP Microlink API example

```php
<?php

$baseUrl = "https://api.microlink.io/";

$params = [
    "url" => "https://docs.stripe.com/api",
    "data.markdown.attr" => "markdown",
    "meta" => "false",
    "embed" => "markdown"
];

$query = http_build_query($params);
$url = $baseUrl . '?' . $query;

$curl = curl_init();

curl_setopt_array($curl, [
    CURLOPT_URL => $url,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_ENCODING => "",
    CURLOPT_MAXREDIRS => 10,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
    CURLOPT_CUSTOMREQUEST => "GET"
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
    echo "cURL Error #: " . $err;
} else {
    echo $response;
}
```

### Golang Microlink API example

```
package main

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

func main() {
    baseURL := "https://api.microlink.io"

    u, err := url.Parse(baseURL)
    if err != nil {
        panic(err)
    }
    q := u.Query()
    q.Set("url", "https://docs.stripe.com/api")
    q.Set("data.markdown.attr", "markdown")
    q.Set("meta", "false")
    q.Set("embed", "markdown")
    u.RawQuery = q.Encode()

    req, err := http.NewRequest("GET", u.String(), nil)
    if err != nil {
        panic(err)
    }

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

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        panic(err)
    }

    fmt.Println(string(body))
}
```

```javascript
importcreateClientfrom'microlink.io'

constmicrolink=createClient()

constmarkdown=awaitmicrolink.markdown('https://docs.stripe.com/api')
```

The response body is Markdown and the content type is `text/markdown`.

The same request as a raw URL:

```bash
https://api.microlink.io?url=https://docs.stripe.com/api&data.markdown.attr=markdown&meta=false&embed=markdown
```

## Scope noisy pages

If the full page includes navigation, footers, or cookie banners, scope the rule to the main content wrapper:

The following examples show how to use the Microlink API with CLI, cURL, JavaScript, Python, Ruby, PHP & Golang, targeting 'https://microlink.io/docs/api/getting-started/overview' URL with 'data', 'meta' & 'embed' API parameters:

### CLI Microlink API example

```bash
microlink https://microlink.io/docs/api/getting-started/overview&data.markdown.selector=main&data.markdown.attr=markdown&embed=markdown
```

### cURL Microlink API example

```bash
curl -G "https://api.microlink.io" \
  -d "url=https://microlink.io/docs/api/getting-started/overview" \
  -d "data.markdown.selector=main" \
  -d "data.markdown.attr=markdown" \
  -d "meta=false" \
  -d "embed=markdown"
```

### JavaScript Microlink API example

```javascript
import createClient from 'microlink.io'

const microlink = createClient()

const markdown = await microlink.markdown('https://microlink.io/docs/api/getting-started/overview', {
  selector: "main"
})
```

### Python Microlink API example

```python
import requests

url = "https://api.microlink.io/"

querystring = {
    "url": "https://microlink.io/docs/api/getting-started/overview",
    "data.markdown.selector": "main",
    "data.markdown.attr": "markdown",
    "meta": "false",
    "embed": "markdown"
}

response = requests.get(url, params=querystring)

print(response.json())
```

### Ruby Microlink API example

```ruby
require 'uri'
require 'net/http'

base_url = "https://api.microlink.io/"

params = {
  url: "https://microlink.io/docs/api/getting-started/overview",
  data.markdown.selector: "main",
  data.markdown.attr: "markdown",
  meta: "false",
  embed: "markdown"
}

uri = URI(base_url)
uri.query = URI.encode_www_form(params)

http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Get.new(uri)
response = http.request(request)

puts response.body
```

### PHP Microlink API example

```php
<?php

$baseUrl = "https://api.microlink.io/";

$params = [
    "url" => "https://microlink.io/docs/api/getting-started/overview",
    "data.markdown.selector" => "main",
    "data.markdown.attr" => "markdown",
    "meta" => "false",
    "embed" => "markdown"
];

$query = http_build_query($params);
$url = $baseUrl . '?' . $query;

$curl = curl_init();

curl_setopt_array($curl, [
    CURLOPT_URL => $url,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_ENCODING => "",
    CURLOPT_MAXREDIRS => 10,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
    CURLOPT_CUSTOMREQUEST => "GET"
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
    echo "cURL Error #: " . $err;
} else {
    echo $response;
}
```

### Golang Microlink API example

```
package main

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

func main() {
    baseURL := "https://api.microlink.io"

    u, err := url.Parse(baseURL)
    if err != nil {
        panic(err)
    }
    q := u.Query()
    q.Set("url", "https://microlink.io/docs/api/getting-started/overview")
    q.Set("data.markdown.selector", "main")
    q.Set("data.markdown.attr", "markdown")
    q.Set("meta", "false")
    q.Set("embed", "markdown")
    u.RawQuery = q.Encode()

    req, err := http.NewRequest("GET", u.String(), nil)
    if err != nil {
        panic(err)
    }

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

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        panic(err)
    }

    fmt.Println(string(body))
}
```

```javascript
importcreateClientfrom'microlink.io'

constmicrolink=createClient()

constmarkdown=awaitmicrolink.markdown('https://microlink.io/docs/api/getting-started/overview',{

selector:"main"

})
```

Use `main`, `article`, or a page-specific [selector](https://microlink.io/docs/sdk/methods/extract/selector) when the full page is too noisy.

## Keep metadata when useful

For LLM and indexing workflows, setting [meta](https://microlink.io/docs/api/parameters/meta) to `true` prepends YAML frontmatter with normalized fields such as title, description, author, publisher, date, word count, and reading time. Keep `meta: false` when you only want the Markdown body.

## YouTube videos

Point [url](https://microlink.io/docs/api/parameters/url) at a YouTube video URL — `watch`, `youtu.be`, `shorts`, or `embed` — and Microlink returns the video's caption transcript as the Markdown body, with `title`, `author`, `image`, and `date` resolved from the video metadata.

The following examples show how to use the Microlink API with CLI, cURL, JavaScript, Python, Ruby, PHP & Golang, targeting 'https://www.youtube.com/watch?v=tY2M2g-tG1Q' URL with 'data' & 'meta' API parameters:

### CLI Microlink API example

```bash
microlink https://www.youtube.com/watch?v=tY2M2g-tG1Q&data.transcript.attr=markdown
```

### cURL Microlink API example

```bash
curl -G "https://api.microlink.io" \
  -d "url=https://www.youtube.com/watch?v=tY2M2g-tG1Q" \
  -d "data.transcript.attr=markdown" \
  -d "meta=false"
```

### JavaScript Microlink API example

```javascript
import createClient from 'microlink.io'

const microlink = createClient()

const { transcript } = await microlink.extract('https://www.youtube.com/watch?v=tY2M2g-tG1Q', {
  transcript: {
    attr: "markdown"
  }
})
```

### Python Microlink API example

```python
import requests

url = "https://api.microlink.io/"

querystring = {
    "url": "https://www.youtube.com/watch?v=tY2M2g-tG1Q",
    "data.transcript.attr": "markdown",
    "meta": "false"
}

response = requests.get(url, params=querystring)

print(response.json())
```

### Ruby Microlink API example

```ruby
require 'uri'
require 'net/http'

base_url = "https://api.microlink.io/"

params = {
  url: "https://www.youtube.com/watch?v=tY2M2g-tG1Q",
  data.transcript.attr: "markdown",
  meta: "false"
}

uri = URI(base_url)
uri.query = URI.encode_www_form(params)

http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Get.new(uri)
response = http.request(request)

puts response.body
```

### PHP Microlink API example

```php
<?php

$baseUrl = "https://api.microlink.io/";

$params = [
    "url" => "https://www.youtube.com/watch?v=tY2M2g-tG1Q",
    "data.transcript.attr" => "markdown",
    "meta" => "false"
];

$query = http_build_query($params);
$url = $baseUrl . '?' . $query;

$curl = curl_init();

curl_setopt_array($curl, [
    CURLOPT_URL => $url,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_ENCODING => "",
    CURLOPT_MAXREDIRS => 10,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
    CURLOPT_CUSTOMREQUEST => "GET"
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
    echo "cURL Error #: " . $err;
} else {
    echo $response;
}
```

### Golang Microlink API example

```
package main

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

func main() {
    baseURL := "https://api.microlink.io"

    u, err := url.Parse(baseURL)
    if err != nil {
        panic(err)
    }
    q := u.Query()
    q.Set("url", "https://www.youtube.com/watch?v=tY2M2g-tG1Q")
    q.Set("data.transcript.attr", "markdown")
    q.Set("meta", "false")
    u.RawQuery = q.Encode()

    req, err := http.NewRequest("GET", u.String(), nil)
    if err != nil {
        panic(err)
    }

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

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        panic(err)
    }

    fmt.Println(string(body))
}
```

```javascript
importcreateClientfrom'microlink.io'

constmicrolink=createClient()

const{transcript}=awaitmicrolink.extract('https://www.youtube.com/watch?v=tY2M2g-tG1Q',{

transcript:{

attr:"markdown"

}

})
```

Read the caption transcript from `data.transcript`.

The transcript is the video's own caption language — manual subtitles when the creator provided them, otherwise the auto-generated ones. Videos without captions, and live or private videos, return the standard metadata without a transcript body.

## Supported source formats

Any HTML page works. Direct file URLs are converted first: PDFs with a text layer, and the office formats `docx`, `xlsx`, `pptx`, `odt`, `rtf`, and `epub`. Image-only PDF scans, the legacy binary formats (`doc`, `xls`, `ppt`), and the OpenDocument spreadsheet and presentation formats (`ods`, `odp`) are not converted: the request still succeeds, but the field is left as the raw response instead of readable Markdown.

## Next step

Use [Data extraction: Page preparation](https://microlink.io/docs/guides/data-extraction/page-preparation) when the output is noisy or incomplete. Use [URL to Text](https://microlink.io/docs/guides/content-conversion/url-to-text) when the consumer only needs readable text, or [URL to HTML](https://microlink.io/docs/guides/content-conversion/url-to-html) when you need markup.

## See also

Every recipe is in the [website to Markdown use cases](https://microlink.io/use-cases/website-to-markdown). The most common ones:

- [Markdown with metadata frontmatter](https://microlink.io/use-cases/website-to-markdown/with-metadata) — title, author, date and reading time on top of the body.
- [Clean Markdown, no boilerplate](https://microlink.io/use-cases/website-to-markdown/clean-content) — scope the conversion to the content.
- [PDF and office documents to Markdown](https://microlink.io/use-cases/website-to-markdown/documents) — the same request for files.
- [YouTube transcripts as Markdown](https://microlink.io/use-cases/website-to-markdown/youtube-transcripts) — captions as a document.