Skip to main content

Confirm

Are you sure?

C# · Code recipe

Get the rendered HTML of a JavaScript page in C#

Fetch the HTML a browser ends up with, JavaScript and all, in .NET 8+ with HttpClient. Every program on this page runs as it stands — each one was run against a stub of the API before it was published.

By · Last updated: September 2026

TL;DR

To get the HTML of a JavaScript-rendered page in C#, POST its URL to https://urlpipe.dev/html with sync set to true. The body is the DOM after the page's scripts ran in real Chrome, serialized as HTML — what a visitor's browser holds, not what the server first sent — read with ReadAsStringAsync, for 1 credit.

Free plan, no credit card. 1,000 credits a month.

One POST to /html loads the page in real Chrome, lets its JavaScript run, and serializes the DOM it ended up with. For a single-page app that is the difference between an empty <div id="root"> and the content; the rendered vs raw HTML guide shows how far apart the two get.

The body is the HTML as text, read with ReadAsStringAsync. The program saves it and reports its size in bytes — compare that with curl -s https://example.com | wc -c and you see how much of the page only exists after the scripts ran.

Setup

Before you start

Nothing to add from NuGet: HttpClient and System.Text.Json are part of .NET. Each program below is a whole Program.cs for a console project.

Terminal
dotnet new console -o RenderedHtml && cd RenderedHtml
export URLPIPE_API_KEY="your_api_key"
# replace Program.cs with a program below, then:
dotnet run

The request

Save the rendered HTML and report its size

sync = true keeps the request open until the result is ready. PostAsJsonAsync serializes the anonymous object, and the property names go out as written, underscores included. HttpClient does not throw on a 4xx or 5xx, so check IsSuccessStatusCode. body.Length counts UTF-16 chars; the size on disk is the UTF-8 byte count.

Program.cs
using System.Net.Http.Headers;
using System.Net.Http.Json;
using System.Text;

// A sync call can take up to 60 s; HttpClient's default gives up at 100.
using var client = new HttpClient { Timeout = TimeSpan.FromSeconds(90) };
client.DefaultRequestHeaders.Authorization =
    new AuthenticationHeaderValue("Bearer", Environment.GetEnvironmentVariable("URLPIPE_API_KEY"));

var response = await client.PostAsJsonAsync("https://urlpipe.dev/html",
    new { url = "https://example.com", sync = true });
var body = await response.Content.ReadAsStringAsync();
if (!response.IsSuccessStatusCode)
{
    Console.Error.WriteLine($"URLpipe answered {(int)response.StatusCode}: {body}");
    return 1;
}

await File.WriteAllTextAsync("page.html", body);
Console.WriteLine($"Saved page.html ({Encoding.UTF8.GetByteCount(body)} bytes)");
return 0;

Run it: dotnet run

Async

The async variant: a token, a webhook and a poll

Leave out sync and the answer is a token, straight away. JsonNode reads one field without declaring a class for the response, and Task.Delay waits between polls without holding a thread.

Program.cs
using System.Net.Http.Headers;
using System.Net.Http.Json;
using System.Text;
using System.Text.Json.Nodes;

const string Api = "https://urlpipe.dev";

using var client = new HttpClient { Timeout = TimeSpan.FromSeconds(30) };
client.DefaultRequestHeaders.Authorization =
    new AuthenticationHeaderValue("Bearer", Environment.GetEnvironmentVariable("URLPIPE_API_KEY"));

// No sync: the request is accepted at once and the work carries on without you.
var accepted = await client.PostAsJsonAsync($"{Api}/html", new
{
    url = "https://example.com",
    report_to = "https://your-app.com/webhooks/urlpipe",
    labels = new { customer = "acme" },
});
if (!accepted.IsSuccessStatusCode)
{
    Console.Error.WriteLine($"URLpipe answered {(int)accepted.StatusCode}: {await accepted.Content.ReadAsStringAsync()}");
    return 1;
}
var token = JsonNode.Parse(await accepted.Content.ReadAsStringAsync())!["token"]!.GetValue<string>();
Console.WriteLine($"Accepted {token}");

// The result is POSTed to report_to when it is ready. Polling by token is the
// other way to collect it: no endpoint needed, and a backup for the webhook.
var response = await client.GetAsync($"{Api}/result/{token}");
for (var attempt = 1; attempt < 60 && (int)response.StatusCode == 202; attempt++) // 202: still processing
{
    await Task.Delay(TimeSpan.FromSeconds(2));
    response = await client.GetAsync($"{Api}/result/{token}");
}

var body = await response.Content.ReadAsStringAsync();
switch ((int)response.StatusCode)
{
    case 200:
        break;
    case 202:
        Console.Error.WriteLine("Still processing after two minutes; try the token again later.");
        return 1;
    case 422:
        Console.Error.WriteLine($"The analysis failed: {JsonNode.Parse(body)?["error"]?.GetValue<string>()}");
        return 1;
    case 410:
        Console.Error.WriteLine("The result is past the 30-day window; send the request again.");
        return 1;
    default:
        Console.Error.WriteLine($"URLpipe answered {(int)response.StatusCode}: {body}");
        return 1;
}

await File.WriteAllTextAsync("page.html", body);
Console.WriteLine($"Saved page.html ({Encoding.UTF8.GetByteCount(body)} bytes)");
return 0;

Run it: dotnet run

Errors

Handle errors and retries

A local function keeps the retry rules next to the call, and the exception type is declared after the top-level statements, where C# requires it. RetryAfter.Delta is the parsed Retry-After header, and a body that is not JSON (a 401 answers in plain text) leaves every field null.

Program.cs
using System.Net.Http.Headers;
using System.Net.Http.Json;
using System.Text;
using System.Text.Json;
using System.Text.Json.Nodes;

using var client = new HttpClient { Timeout = TimeSpan.FromSeconds(90) };
client.DefaultRequestHeaders.Authorization =
    new AuthenticationHeaderValue("Bearer", Environment.GetEnvironmentVariable("URLPIPE_API_KEY"));

string body;
try
{
    body = await Urlpipe("/html", new { url = "https://example.com", sync = true });
}
catch (URLpipeException e)
{
    Console.Error.WriteLine($"URLpipe: {e.Message}");
    return 1;
}

await File.WriteAllTextAsync("page.html", body);
Console.WriteLine($"Saved page.html ({Encoding.UTF8.GetByteCount(body)} bytes)");
return 0;

// POST a sync request and return the result body; retry the two 429s that clear by themselves.
async Task<string> Urlpipe(string path, object payload, int attempts = 5)
{
    for (var attempt = 0; attempt < attempts; attempt++)
    {
        using var response = await client.PostAsJsonAsync($"https://urlpipe.dev{path}", payload);
        var text = await response.Content.ReadAsStringAsync();
        var status = (int)response.StatusCode;
        if (status == 200) return text;
        if (status == 401) throw new URLpipeException("401: the API key is missing or wrong. Check URLPIPE_API_KEY.");

        JsonNode? error = null;
        try { error = JsonNode.Parse(text); } catch (JsonException) { } // not JSON: no fields
        var code = error?["error"]?.GetValue<string>() ?? "";
        var message = error?["message"]?.GetValue<string>();
        var detail = message is null ? code : $"{code}: {message}";

        if (status == 429 && code == "rate_limited")
            // Sending too fast: Retry-After says how long the window has left.
            await Task.Delay(response.Headers.RetryAfter?.Delta ?? TimeSpan.FromSeconds(1));
        else if (status == 429 && code == "concurrency_limit")
            // Every parallel slot on your plan is busy with your own requests.
            await Task.Delay(TimeSpan.FromSeconds(Math.Pow(2, attempt)));
        else if (status == 504)
            // Still running on our side; the token collects it from GET /result/:token.
            throw new URLpipeException($"504 processing_timeout: collect it later with token {error?["token"]?.GetValue<string>()}");
        else
            // 403 email_unverified, 422 (a bad parameter, or a page that would not load),
            // 429 quota_exceeded: sending the same request again gets the same answer.
            throw new URLpipeException($"{status}: {detail}");
    }
    throw new URLpipeException($"429: still refused after {attempts} attempts");
}

class URLpipeException(string message) : Exception(message) { }

Run it: dotnet run

Details

What to know about /html

  • The HTML is serialized from the live DOM, so it is well-formed but not byte-identical to any file on the server.
  • Pages over 10 MB of HTML are refused with The page is too big to be processed.
  • page_options.wait_for_selector waits for an element that loads late; delay waits a fixed time on top.
  • It is the whole document, scripts and styles included, not a cleaned-up version of it. For clean text, use Markdown instead.

Other languages

Get the rendered HTML of a JavaScript page in another language

More C#: every C# recipe

FAQ

Frequently asked questions

How is this different from fetching the URL myself?
A plain GET returns what the server sent before any JavaScript ran. /html returns the DOM after the page's scripts ran in real Chrome — the HTML a visitor's browser actually holds.
Can I wait for content that loads late?
Yes: page_options.wait_for_selector waits up to 10 seconds for an element to appear, and delay adds a fixed wait. If the element never appears the request is a 422 and costs nothing.
Does URLpipe follow robots.txt?
Yes, by default, for every project. You can turn it off per project, and then you are responsible for having the right to fetch those pages.
Do I need an SDK to call URLpipe from C#?
No NuGet package: HttpClient and System.Text.Json are part of .NET, and the API is one POST per job.

Get a key and run it.

Free plan, no card. Paste your key into URLPIPE_API_KEY and every program on this page runs as it is.