Make HTTP request from inside WebAssembly

(Wannabe-awesome) list of approaches (recipes, frameworks, http client libraries, etc) to send outbound HTTP(S) requests from inside WebAssembly.

Language	Browsers and V8-based runtimes	Standalone / server-side / WASI runtimes
Ada	AdaWebPack
AssemblyScript	as-fetch	wasi-http
BASIC	EndBASIC, gobasic
C# / .Net	Blazor, OpenSilver, RestSharp, System.Net.Http.HttpClient, Uno Platform	Extism PDK for .NET, Spin SDK for .NET, wasi-http
C / C++	Emscripten, xxhr	Extism PDK for C, httpclient_wasmedge_socket, wasi-http
Crystal	crystal-js
Dart	package:http, package:web, dio, fetch_api, fetch_client, dart:js_interop, requests, Cloudflare Workers SDK
Forth	WAForth
Golang / TinyGo	net/http, wasm-fetch, Nigel2392/requester, Anko, Risor, Tengo, Hogosuru, Vecty, Vugu, Yaegi	Capsule, Extism PDK for Go, go-plugin, Spin SDK for Go, dispatchrun/net, wasi-http, wasi-http-go, Wasm Workers Server
Haskell		Extism PDK for Haskell
Java	Bytecoder	spin-teavm-example
JavaScript	Goja, gojax/fetch, Jint, libcurl.js, Otto, quickjs-emscripten, sebastianwessel/quickjs	WasmEdge-QuickJs, Extism PDK for JS, Spin SDK for JS / TS, Wasm Workers Server
Kotlin	Kotlin/Wasm
Lisp	Janet
Lua	Wasmoon, gluahttp, lmodhttpclient, gopher-lua-libs, Pluto
PHP	php-wasm
Pascal	Free Pascal
Perl	WebPerl
Prolog	ichiban/prolog, Scryer Prolog, SWI-Prolog, trealla-js	Spin SDK for Prolog
Python	RustPython, Pyodide, pyodide-http, GPython, JupyterLite, PyScript, Panel, PocketPy, RPython, Stlite, urllib3, micropython-wasm	componentize-py, Extism PDK for Python, Spin SDK for Python
R	webR
Ruby	ruby.wasm
Rust	wasm-bindgen, Cloudflare Workers SDK, ehttp, gloo_net, httpc, http-client, iced, leptos, localghost, MoonZoon, quad-net, reqwasm, reqwest, sauron, seed, surf, sycamore Scripting: Rune	reqwest, http_req, Extism PDK for Rust, Spin SDK for Rust, waki, wasi-http, Wasm Workers Server
Starlark	starlark-go, starlark-go-nethttp, starlib, starlight, starlight-enhanced
Swift	SwiftWasm
Tcl	criTiCaL, Wacl
Wonkey	Wonkey/httprequest
Zig		Extism PDK for Zig, Spin SDK for Zig
Misc langs	Berry: berry , Expression: Cel-go, Expr , Rebol: rye	MoonBit: Extism PDK for MoonBit, Virgil: Extism PDK for Virgil

Browser WASM runtimes and V8-based runtimes like Node.js and Deno, also Bun

Ada

Product / Implementation TLDR: Usage TLDR: Example code Doc Online demo WASM Runtime Internals: method to do real request

AdaWebPack

L   : aliased Listener;
xhr : Web.XHR.Requests.XML_Http_Request;

overriding procedure Handle_Event
  (Self : in out Listener; Event : in out Web.DOM.Events.Event'Class)
is
  use type Web.XHR.Requests.State;
begin
  if xhr.Get_Ready_State = Web.XHR.Requests.DONE then
    WASM.Console.Log (xhr.Get_Response_Text);
  end if;
end Handle_Event;

procedure Initialize_Example is
begin
  xhr := Web.XHR.Requests.Constructors.New_XML_Http_Request;
  xhr.Open ("GET", "https://httpbin.org/anything");
  xhr.Send ("");
  xhr.Add_Event_Listener ("readystatechange", L'Access);
end Initialize_Example;

Example

Browser

Manual JS XMLHttpRequest interop by using the wrapper for imported JS-side code.

AssemblyScript

Product / Implementation TLDR: Usage TLDR: Example code Doc Online demo WASM Runtime Internals: method to do real request

as-fetch

import { fetch } from "as-fetch/assembly";

export { responseHandler } from "as-fetch/assembly";

fetch("https://httpbin.org/anything", {
  method: "GET",
  mode: "no-cors",
  headers: [],
  body: null,
}).then((resp) => {
  const text = resp.text();
});

Example

Readme

Browser, Node.js, and Deno

JS fetch interop by importing the function from runtime

BASIC

Product / Implementation TLDR: Usage TLDR: Example code Doc Online demo WASM Runtime Internals: method to do real request

EndBASIC

DIM res AS STRING
' Custom function
res = HTTPGET("https://httpbin.org/anything")
PRINT res

Example for LOGIN command

Some info

Playground

_{Type LOGIN "usr","pwd" there, and it will invoke a POST request}

Browser

Using reqwest for API calls in REPL

gobasic

REM Custom function
res$ = HTTPGET ("https://httpbin.org/anything")
PRINT res$

Example

Readme

Browser, Bun, and Deno.

Uses Golang's "net/http" in a custom function injected into the language.

Berry

Product / Implementation	TLDR: Usage	TLDR: Example code	Doc	Online demo	WASM Runtime	Internals: method to do real request
Berry	# custom function print(httpget('https://httpbin.org/anything'))	Example	Doc Doc	Demo Dev Container	Browser	JS `XMLHttpRequest` interop by invoking `emscripten_fetch()` from a custom host function injected as native function into Berry.

C#

Product / Implementation	TLDR: Usage	TLDR: Example code	Doc	Online demo	WASM Runtime	Internals: method to do real request
Blazor	@using System.Net.Http.Json @inject HttpClient HttpClient @code { var data = await HttpClient.GetFromJsonAsync<JsonElement>( "https://httpbin.org/anything"); }	Example	Tutorial Doc	Demo by JasonWatmore _{Demo source}	Browser, also native server-side	JS `fetch` interop by calling to TS wrapper
OpenSilver _{Silverlight / WPF revived in WASM form}	using System; using System.Net.Http; HttpClient client = new HttpClient(); string uri = "https://httpbin.org/anything"; string responseText = await client.GetStringAsync(uri); Console.WriteLine("text: " + responseText);	Example Example for POST	Doc	Demo	Browser	Recommended: just directly invoke .NET's `"Http.HttpClient"`. In `OpenSilver.Compatibility.WebClient` wrapper: JS `XMLHttpRequest` interop.
RestSharp	using System; using RestSharp; var client = new RestClient(); var req = new RestRequest("http://httpbin.org/anything"); var res = await client.ExecuteGetAsync(req); Console.WriteLine("text: " + res.Content);	Example Test	Doc	Demo Dev Container	Browser, Node, Bun, and Deno.	wrapper around .NET's `"Http.HttpClient"`.
System.Net. Http.HttpClient _{Standard library}	using System; using System.Net.Http; HttpClient client = new HttpClient(); string uri = "https://httpbin.org/anything"; string responseText = await client.GetStringAsync(uri); Console.WriteLine("body: " + responseText);	Example	Doc Doc	Demo Dev Container	Browser, Node, Bun, and Deno.	JS `fetch` interop _{(for Node)} from managed code by importing a TS wrapper.
Uno Platform	using System; using System.Net.Http; HttpClient client = new HttpClient(); string uri = "https://httpbin.org/anything"; string txt = await client.GetStringAsync(uri); Console.WriteLine("text: " + txt);	Example	Tutorial		Browser	Using .NET's `"Http.HttpClient"`.

C / C++

Product / Implementation TLDR: Usage TLDR: Example code Doc Online demo WASM Runtime Internals: method to do real request

Emscripten

#include <emscripten/fetch.h>

void requestOnSuccess(emscripten_fetch_t *fetch)
{
    char dat[fetch->numBytes + 1];
    memcpy(dat, fetch->data, fetch->numBytes);
    dat[fetch->numBytes] = '\0';
    printf("data: %s \n", dat);
    emscripten_fetch_close(fetch);
}

emscripten_fetch_attr_t attr;
emscripten_fetch_attr_init(&attr);
strcpy(attr.requestMethod, "GET");
attr.attributes = EMSCRIPTEN_FETCH_LOAD_TO_MEMORY;
attr.onsuccess = requestOnSuccess;
emscripten_fetch(&attr, "https://httpbin.org/anything");

Doc

Browser

JS XMLHttpRequest interop mapped to be used in emscripten_fetch().

nxxm/xxhr

#include <xxhr/xxhr.hpp>

using namespace xxhr;
 
GET( "https://httpbin.org/anything"s, 
  on_response = [](auto res) { std::cout << res.text; }
);

Example

Doc

Browser, Node.js, and Deno

JS XMLHttpRequest Interop

Crystal

Product / Implementation TLDR: Usage TLDR: Example code Doc Online demo WASM Runtime Internals: method to do real request

lbguilherme/crystal-js

require "js"

class XMLHttpRequest < JS::Reference
  @[JS::Method]
  def self.new : self
    <<-js
      return new XMLHttpRequest();
    js
  end

  js_getter responseText : String

  js_method send
  js_method open(method : String, url : String, async : Int32)
end

req = XMLHttpRequest.new
req.open("GET", "https://httpbin.org/anything", 0)
req.send
JS.console.log req.response_text

Readme

Browser, Node.js, and Deno

Manual JS XMLHttpRequest interop by creating the wrapper using crystal-js shard.

Dart

Product / Implementation	TLDR: Usage	TLDR: Example code	Doc	Online demo	WASM Runtime	Internals: method to do real request
package:dio	import 'package:dio/dio.dart'; final dio = Dio(); Response response = await dio.get( 'https://httpbin.org/anything'); print(response);	Example Example Example	Readme	Demo Dev Container	Browser with Wasm-GC support enabled¹	JS `XMLHttpRequest` interop inside `BrowserHttpClientAdapter` class.
package:fetch_api	import 'package:fetch_api/fetch_api.dart'; final resp = await fetch( 'https://httpbin.org/anything'); final txt = await resp.text(); print('${txt}');	Example Example using `Request` Example	Some doc	Demo Dev Container	Browser with Wasm-GC support enabled¹, Node.js, and Deno.	JS `fetch` interop using imported by `@JS` function.
package:fetch_client	import 'package:fetch_client/fetch_client.dart'; final client = FetchClient( mode: RequestMode.cors); final uri = Uri.parse( 'https://httpbin.org/anything'); final resp = await client.get(uri); print('${resp.body}'); client.close();	Example Example	Some doc	Demo Dev Container	Browser with Wasm-GC support enabled¹, Node.js, and Deno.	Extends the `BaseClient` by using imported package:fetch_api.
package:http	import 'package:http/http.dart' as http; final resp = await http.get( Uri.parse('https://httpbin.org/anything')); print('${resp.body}');	Example Example Example	Doc	Demo Dev Container Playground	Browser with Wasm-GC support enabled¹	JS `XMLHttpRequest` interop inside `BrowserClient` class.
package:requests	import 'package:requests/requests.dart'; final resp = await Requests.get( 'https://httpbin.org/anything'); print('body: ${resp.content()}');	Example	Readme	Demo Dev Container	Browser with Wasm-GC support enabled¹	Wrapper over package:http.
package:web	import 'package:web/web.dart' as web; final resp = await web.window.fetch( 'https://httpbin.org/anything'.toJS).toDart; final txt = await resp.text().toDart; print('${txt}');	Example	Doc	Demo Dev Container Playground	Browser with Wasm-GC support enabled¹	Direct `fetch` interop with help of some extension types.
dart:js_interop	import 'dart:js_interop'; @JS() external JSPromise<Response> fetch(JSString _); extension type Response(JSObject _) implements JSObject { @JS() external JSPromise<JSString> text(); } final Response resp = await fetch( 'https://httpbin.org/anything'.toJS).toDart; final txt = await resp.text().toDart; print('body: ${txt}');	Example	Doc	Demo Dev Container	Browser with Wasm-GC support enabled¹, Node.js, Bun, and Deno.	Direct JS `fetch` interop by importing it and wrapping its promise with an extension type.
SDK for writing Cloudflare Workers in Dart aka cf_workers.dart	import 'package:http/http.dart'; import 'package:cf_workers/cf_workers.dart'; import 'package:cf_workers/http.dart'; Future<void> main() { return Workers((JSRequest req) async { return fetch(Request('GET', Uri.parse( 'https://httpbin.org/anything')).toJS); }).serve(); }	Example	Readme	Dev Container	workerd, Cloudflare's JavaScript/ Wasm Runtime	JS `fetch` interop using the `fetch()` imported from CF Workers runtime.

Expression evaluation languages

Product / Implementation TLDR: Usage TLDR: Example code Doc Online demo WASM Runtime Internals: method to do real request

Cel-go

_{Common Expression Language}

// two custom functions
println(httpget('https://httpbin.org/anything'))

Example

Doc

Browser, Bun, and Deno.

Using Golang's "net/http" via mapping a custom function into Cel-go.

Expr

// two custom functions
println(httpget('https://httpbin.org/anything'))

Example

Doc

Browser, Bun, and Deno.

Using Golang's "net/http" via mapping a custom function into Expr-lang.

Forth

Product / Implementation	TLDR: Usage	TLDR: Example code	Doc	Online demo	WASM Runtime	Internals: method to do real request
WAForth	: URL$ S" https://httpbin.org/anything" ; ( custom word ) URL$ HTTPGET	Example Example Example for NodeJS	Readme	Demo Dev Container	Browser, NodeJS, Bun, and Deno.	JS `fetch` interop by invoking a custom host function, bound info Forth's dictionary/namespace.

Golang

Product / Implementation	TLDR: Usage	TLDR: Example code	Doc	Online demo	WASM Runtime	Internals: method to do real request
Golang	import "net/http" resp, err := http.Get("https://httpbin.org/anything")	Sample by SamDz16 Sample by salrashid123	fetch options		Browser and Node.js	JS `fetch` Interop
marwan.io/wasm-fetch _{Save 4 MB of wasm binary size}	import "marwan.io/wasm-fetch" resp, err := fetch.Fetch("https://httpbin.org/anything", &fetch.Opts{}) if err == nil { println(string(resp.Body)) }	Example	Doc		Browser and Node.js	Direct JS `fetch` Interop
Nigel2392/requester	import "github.com/Nigel2392/requester" var client = requester.NewAPIClient() client.Get("https://httpbin.org/anything").Do( func(response *http.Response) { body, err := io.ReadAll(response.Body) if err == nil { fmt.Println(string(body)) } } )	Test Example	Sources	Demo Dev Container	Browser and maybe Node.js	Uses Golang's `"net/http"`
Hogosuru _{SPA framework}	import ( "github.com/realPy/hogosuru" "github.com/realPy/hogosuru/base/fetch" "github.com/realPy/hogosuru/base/promise" "github.com/realPy/hogosuru/base/response" ) f, err := fetch.New("https://httpbin.org/anything", nil) f.Then(func(r response.Response) promise.Promise { txtpromise, _ := f.Then( func(r response.Response) promise.Promise { if prm, err := r.Text(); hogosuru.AssertErr(err) { return &prm } return nil }, nil) txtpromise.Then(func(i interface{}) *promise.Promise { fmt.Println(i.(string)) return nil }, nil) return nil }, nil)	Example Example for POST Example for Example for XHR and POST Example	Doc Doc Doc for XHR	Demo Dev Container	Browser	Manual low-level JS `fetch` and `XMLHttpRequest` interop using Go wrappers for Web API: `fetch`, `XHR`.
Vecty _{UI library}	import "io" import "log" import "net/http" go func() { resp, _ := http.Get(action.Url) defer resp.Body.Close() body, _ := io.ReadAll(resp.Body) log.Println(string(body)) }()	Example Example	Use `go func()`	Demo Dev Container	Browser	Has no built-in solutions, just directly invoking Golang's `"net/http"`
Vugu _{UI library}	import "io" import "log" import "net/http" resp, _ := http.Get("https://httpbin.org/anything") defer resp.Body.Close() body, _ := io.ReadAll(resp.Body) log.Println(string(body))	Example		Possible with Dev Container	Browser	Has no built-in solutions, just directly invoking Golang's `"net/http"`
Yaegi _{It's VM / interpreter}	import ( "fmt"; "io"; "net/http" ) resp, _ := http.Get("https://httpbin.org/anything") defer resp.Body.Close() body, _ := io.ReadAll(resp.Body) fmt.Println(string(body))	Example	Some doc	Demo Dev Container	Browser, Bun, and Deno.	Directly invoking Golang's `"net/http"` via mapping.

Golang-like languages

Product / Implementation TLDR: Usage TLDR: Example code Doc Online demo WASM Runtime Internals: method to do real request

Anko

var http = import("net/http")
var ioutil = import("io/ioutil")

var url = "https://httpbin.org/anything"
res, _ = http.DefaultClient.Get(url)
b, _ = ioutil.ReadAll(res.Body)
println(toString(b))
res.Body.Close()

Browser and maybe Node

Directly invoking Golang's "net/http" via mapping.

Risor

url := "https://httpbin.org/anything"
resp := fetch(url)
print(resp.text())

Doc

Browser and maybe Node

Using Golang's "net/http" via mapping.

TengoHTTP

_{for Tengo}

fmt := import("fmt")
http := import("httpclient")

resp := http.request("https://httpbin.org/anything", "GET")
fmt.print(is_error(resp) ? resp : resp.body)

Readme

Browser, Bun, and Deno.

Using Golang's "net/http" via mapping.

Java / JVM

Product / Implementation TLDR: Usage TLDR: Example code Doc Online demo WASM Runtime Internals: method to do real request

mirkosertic/Bytecoder

_{transpile JVM bytecode to Wasm}

import de.mirkosertic.bytecoder.api.web.*;

final Window win = Window.window();
final Console con = Console.console();

win.fetch("https://httpbin.org/anything").then(
 new Promise.Handler<Response>() {
  @Override
  public void handleObject(final Response resp) {
    resp.text().then(new StringPromise.Handler() {
      @Override
      public void handleString(final String text) {
        con.log(text);
      }
    });
  }
});

Test

Some doc

Browser, Node.js, and Deno

Direct fetch
interop using imported JS window object.

JavaScript

Using browser's own JavaScript VM

Possible, but why?

Libraries to use from JavaScript

Product / Implementation

TLDR: Usage

TLDR: Example code

Doc

Online demo

WASM Runtime

Internals: method to do real request

libcurl.js

_{Requires server-side counterpart}

libcurl.set_websocket(
  'wss://your-wisp-proxy.yoursite.tld/');
let res = await libcurl.fetch(
  'https://httpbin.org/anything');
console.log(await res.text());

Doc

Dev Container

Browser

Tunneling TCP to WebSocket using protocols "wisp" or "wsproxy" .

JavaScript VM or interpreter compiled to WASM

JavaScript built with Emscripten

Product / Implementation	TLDR: Usage	TLDR: Example code	Doc	Online demo	WASM Runtime	Internals: method to do real request
quickjs-emscripten	// Host function const txt = await fetch('https://httpbin.org/anything'); console.log(txt);	Example	Doc	Demo Dev Container	Browser, Bun, Deno, and Node.	JS `fetch` interop by injecting a custom host function into QuickJS's global namespace.
sebastianwessel/quickjs	const fn = async () => { // Host function const res = await fetch( 'https://httpbin.org/anything'); return res.text(); } export default await fn();	Example Example for browser Example for Node	Doc	Playground Demo Dev Container	Browser, Bun, Deno, and Node.	Wrapper over quickjs-emscripten. Uses host function `fetch()`.

JavaScript implemented in .NET

Product / Implementation	TLDR: Usage	TLDR: Example code	Doc	Online demo	WASM Runtime	Internals: method to do real request
Jint	// custom object http.get('https://httpbin.org/anything');	Example	Readme	Demo Dev Container	Browser	Using .NET's `"Http.HttpClient"` via mapping a custom object inside JS.

JavaScript implemented in Golang

Product / Implementation	TLDR: Usage	TLDR: Example code	Doc	Online demo	WASM Runtime	Internals: method to do real request
Goja	const res = httpget('https://httpbin.org/anything'); console.log(res);	Example	Some doc	Demo Dev Container	Browser, Bun, and Deno.	Using Golang's `"net/http"` via mapping a custom function inside JS.
gojax/fetch	fetch('https://httpbin.org/anything') .then(function(res) { return res.text(); }).then(function(txt) { console.log(txt); exitloop(); });	Example Test Example	Readme	Demo Dev Container	Browser, Bun, and Deno.	Injecting a custom function into JS. That func uses the goproxy as HTTP client, which is a wrapper for Golang's `"net/http"`.
Otto	const res = httpget('https://httpbin.org/anything'); console.log(res);	Example	Some doc	Demo Dev Container	Browser, Bun, and Deno.	Using Golang's `"net/http"` via mapping a custom function inside JS.

Kotlin

Product / Implementation TLDR: Usage TLDR: Example code Doc Online demo WASM Runtime Internals: method to do real request

Kotlin/Wasm

_{still Alpha}

import kotlinx.browser.window

window.fetch("https://httpbin.org/anything").then {
  if (it.ok) {
    it.text().then {
      println(it)
      null
    }
  }
  null
}

Readme

Browser with Wasm-GC and Wasm-Exception-Handling support enabled¹, Node v21 and above, Deno v1.38 and above.

Direct fetch interop using exposed JS window object. For Node/Deno, just import.

Lisp

Clojure-like languages

Product / Implementation	TLDR: Usage	TLDR: Example code	Doc	Online demo	WASM Runtime	Internals: method to do real request
Janet	# custom function (print (httpget `https://httpbin.org/anything`))	Example	Some doc	Demo Dev Container	Browser and maybe Node	JS `XMLHttpRequest` interop by invoking `emscripten_fetch()` from a custom host function injected into Janet.

Lua

Product / Implementation	TLDR: Usage	TLDR: Example code	Doc	Online demo	WASM Runtime	Internals: method to do real request
Wasmoon	local resp = fetch('https://httpbin.org/anything'):await() local text = resp:text():await() print(text)	Example	Some doc	Dev Container	Browser, Node.js, and Deno	Direct `fetch` interop by manually importing it into Lua using `lua.global.set()`.

Lua implemented in Golang

Product / Implementation TLDR: Usage TLDR: Example code Doc Online demo WASM Runtime Internals: method to do real request

cjoudrey/gluahttp

local http = require('http')
local res, err = http.request('GET', 
  'https://httpbin.org/anything', {
  headers={
    ['User-Agent']='gluahttp/wasm'
  }
})
print(res.body)

Example

Readme

Browser and maybe Node

Using Golang's "net/http" via mapping.

gopher-lua-libs

local http = require('http')
local client = http.client()
local req = http.request('GET', 
  'https://httpbin.org/anything')
local res, err = client:do_request(req)
print(res.body)

Doc

Browser and maybe Node

Using Golang's "net/http" via mapping.

erdian718/lmodhttpclient _{aka ofunc/lmodhttpclient}

local io = require('io')
local httpclient = require('http/client')

local res = httpclient.get(
  'https://httpbin.org/anything')
io.copy(res, io.stdout)
res:close()

Example

Readme

Browser and maybe Node

Using Golang's "net/http" via mapping.

Lua dialects

Product / Implementation	TLDR: Usage	TLDR: Example code	Doc	Online demo	WASM Runtime	Internals: method to do real request
Pluto	local http = require 'pluto:http' http.request('https://httpbin.org/anything') \|> print	Example 1 Example 2	Doc Doc for pipe	JSON Demo Demo Demo	Browser and maybe Node.	JS `XMLHttpRequest` interop by invoking `emscripten_fetch()`.

PHP

Product / Implementation TLDR: Usage TLDR: Example code Doc Online demo WASM Runtime Internals: method to do real request

php-wasm

_{Fork of PIB}

$url = 'https://httpbin.org/anything';

$window = new Vrzno();
$window->fetch($url)
->then(function($res) { return $res->text(); })
->then(var_dump(...));

Browser, Bun, Deno, Node, and CloudFlare Workers.

Manual JS fetch interop using vrzno PHP extension.

Pascal

Product / Implementation	TLDR: Usage	TLDR: Example code	Doc	Online demo	WASM Runtime	Internals: method to do real request
Free Pascal	function httpGet(url: ShortString; Var str_out: ShortString): ShortString; external 'js'; var out_str : ShortString; begin out_str:= DupeString( ' ' , 255 ); httpGet('https://httpbin.org/anything', out_str); writeln(out_str); end.	Example		Demo Dev Container	Browser and maybe Node	Direct `XMLHttpRequest` interop in sync mode via importing the JS function into Pascal with mapping.

Perl

Product / Implementation	TLDR: Usage	TLDR: Example code	Doc	Online demo	WASM Runtime	Internals: method to do real request
WebPerl	use WebPerl qw/js js_new sub_once/; my $xhr = js_new('XMLHttpRequest'); $xhr->addEventListener('load', sub_once { print 'Done: '.$xhr->{responseText}; }); $xhr->open('GET', 'https://httpbin.org/anything', 0); $xhr->send();	Example 1 Example 2	Forum post	Demo Playground	Browser, Node.js, and Deno	Manual JS `XMLHttpRequest` interop using `WebPerl.pm` module.

Prolog

Product / Implementation	TLDR: Usage	TLDR: Example code	Doc	Online demo	WASM Runtime	Internals: method to do real request
Scryer Prolog	:- use_module(library(wasm)). ?- js_eval("const xhr=new XMLHttpRequest(); xhr.open('GET','https://httpbin.org/anything',false); xhr.send(); xhr.responseText;", Txt), format("~s", [Txt]).	<--	Doc Readme	Example code works in Playground	Browser	Manual JS `XMLHttpRequest` interop using `js_eval` predicate.
SWI-Prolog	fetch('https://httpbin.org/anything', text, Out).	<--	Doc	Example code works in Playground	Browser and Node	JS `fetch` interop by declaring the predicate.
trealla-js	js_eval("return fetch('https://httpbin.org/anything').then(r => r.text());", Txt).	Example Example	Readme	Example code works in Playground	Browser and Node	Manual invoking of JS `fetch` using `js_eval` predicate.

Prolog implemented in Golang

Product / Implementation	TLDR: Usage	TLDR: Example code	Doc	Online demo	WASM Runtime	Internals: method to do real request
ichiban/prolog	% custom predicate httpget("https://httpbin.org/anything", RespTxt).	Example Example	Readme	Demo Dev Container	Browser, Bun, and Deno.	Using Golang's `"net/http"` via mapping a custom predicate inside Prolog.

Python

Product / Implementation	TLDR: Usage	TLDR: Example code	Doc	Online demo	WASM Runtime	Internals: method to do real request
RustPython	from browser import fetch fetch('https://httpbin.org/anything').then( lambda resp: print((resp)))	Example		Playground _{source of demo}	Browser, Node.js, and maybe Deno	JS `fetch` Interop
Pyodide	from pyodide.http import pyfetch response = await pyfetch("https://httpbin.org/anything") _{Also note that the pyodide-http is bundled in Pyodide.}	3 Ways to Implement Network Requests in Pyodide by lwebapp some code StackOverflow question	pyodide.http Doc	Playground `fetch` Playground by lwebapp	Browser, Node.js, and maybe Deno	JS `fetch` Interop
koenvo/pyodide-http `requests` and `urlopen` in Pyodide	# needs `await micropip.install(['pyodide-http', 'requests'])` import pyodide_http pyodide_http.patch_all() import requests response = requests.get("https://httpbin.org/anything")	Example Patching example Patching example from panel	Supported packages	Playground	Browser and maybe Node.js	JS `fetch` and `XMLHttpRequest` Interop using Pyodide's `js` scope.
urllib3 _{Since 2.2.0}	import micropip await micropip.install('urllib3') import urllib3 res = urllib3.request('GET', 'https://httpbin.org/anything') print(res.data.decode('utf-8')) # using requests import micropip await micropip.install('requests') import requests res = requests.get('https://httpbin.org/anything') print(res.text)	Example requests Example	Doc	Playground	Browser only (yet)	JS `fetch` interop or `XMLHttpRequest` interop if `fetch` is not available.
GPython	import httpclient print(httpclient.Get('https://httpbin.org/anything'))	Example	Some doc	Demo Dev Container	Browser, Bun, and Deno.	Using Golang's `"net/http"` via mapping.
PyScript	from pyodide.http import pyfetch, FetchResponse import asyncio async def req() -> FetchResponse: response = await pyfetch("https://httpbin.org/anything") print(await response.string()) asyncio.ensure_future(req())	Example	Doc	Playground 1 Playground 2	Browser	Uses pyodide's facilities
Panel	response = requests.get("https://httpbin.org/anything")	Example Old example	Doc		Browser	Employs koenvo/pyodide-http. Also direct `XMLHttpRequest` interop for image data.
JupyterLite	# using Pandas import pyodide_http; pyodide_http.patch_all() import pandas as pd data = pd.read_json('https://httpbin.org/json') data # using js.fetch from js import fetch res = await fetch('https://httpbin.org/anything') text = await res.text() print(text) # using requests import micropip; await micropip.install(['requests']) import pyodide_http; pyodide_http.patch_all() import requests res = requests.get("https://httpbin.org/anything") print(res.text)	Example Example Example	Doc	Playground	Browser	Employing `pyodide-http` and Pyodide's own facilities.
micropython-wasm	import js fetch = JS('fetch') response = fetch('https://httpbin.org/anything').wait() text = response.text().wait() print(text)	Example 1 Example 2	Readme	Dev Container	Browser and Node.js	Direct `fetch` interop using js module, by employing Emscripten APIs.
Stlite _{a port of Streamlit to Wasm}	from pyodide.http import pyfetch import streamlit as st response = await pyfetch("https://httpbin.org/anything") body = await response.string() st.write(body)	Example 1 Example 2 Pandas + open_url example	Readme	Playground	Browser	Uses pyodide's facilities.
PocketPy _{lightweight Python 3.x}	# custom module import http print(http.get('https://httpbin.org/anything'))	Example	Some doc	Demo Dev Container	Browser	JS `XMLHttpRequest` interop by invoking `emscripten_fetch()` from a custom host function injected as module function into Python.

Python-like languages

Product / Implementation TLDR: Usage TLDR: Example code Doc Online demo WASM Runtime Internals: method to do real request

soIu/rpython

_{It's compiler}

from javascript import Object, asynchronous, JSON

@asynchronous
def send_request(url):
  fetch = Object('fetch')
  res = fetch.call(url).wait()
  text = res['text'].call().wait()
  print(text)
  return text
  
def target(*args): return main, None

def main(argv):
  send_request('https://httpbin.org/anything')
  return 0

if __name__ == '__main__':
  import sys
  main(sys.argv)

Example

Some doc

Browser, Node.js, and Deno

Direct fetch interop using javascript module, by employing Emscripten APIs.

R

Product / Implementation	TLDR: Usage	TLDR: Example code	Doc	Online demo	WASM Runtime	Internals: method to do real request
webR	df <- read.csv("https://httpbin.org/anything") print(df) // All works: read.table() variants, download.file(), scan(), url(), etc		Doc	Playground Old Playground	Browser and Node	Implemented `xhr` transport which uses JS `XMLHttpRequest` interop by calling web worker using Emscripten APIs.

Rebol

Rebol-like languages

Product / Implementation	TLDR: Usage	TLDR: Example code	Doc	Online demo	WASM Runtime	Internals: method to do real request
Rye	go does { get https://httpbin.org/anything \|print }	Example Example Example	Some doc for embedding	Playground Dev Container	Browser	Using Golang's `"net/http"` via mapping to a Rye word.

Ruby

Product / Implementation	TLDR: Usage	TLDR: Example code	Doc	Online demo	WASM Runtime	Internals: method to do real request
ruby.wasm	require 'js' resp = JS.global.fetch('https://httpbin.org/anything').await puts resp.text.await	Example 1 from bormashino Example 2 from ruby-wasm-duckdb Example 3 from irb.wasm Example 4 from irb.wasm	Doc	TryRuby Demo irb-wasm Playground	Browser, Node.js, and maybe Deno	Direct JS `fetch` Interop

Rust

Product / Implementation	TLDR: Usage	TLDR: Example code	Doc	Online demo	WASM Runtime	Internals: method to do real request
wasm-bindgen	let window = web_sys::window().unwrap(); let resp_val = JsFuture::from( window.fetch_with_str("https://httpbin.org/anything")).await?;	Example	Fetch API docs	Demo _{Prints to browser console, source}	Browser, Node.js, and Deno	JS `fetch` Interop
Rust SDK for writing Cloudflare Workers aka workers-rs	let mut resp = Fetch::Url( "https://httpbin.org/anything" .parse().unwrap(), ) .send().await?; let txt = resp.text().await?;	Example 1 Example 2	Doc		workerd, Cloudflare's JavaScript/ Wasm Runtime	JS `fetch` interop using wasm-bindgen
ehttp	let request = ehttp::Request::get("https://httpbin.org/anything"); ehttp::fetch(request, move \|result: ehttp::Result<ehttp::Response>\| { println!("Text: {:?}", result.unwrap().text()); });	Example	Doc	Demo	Browser, Node.js, and Deno. Also native	JS `fetch` Interop using wasm-bindgen
httpc	let uri = Uri::from_static("https://httpbin.org/anything"); let req = Request::get(uri).body(None).unwrap(); let client = web_sys::window(); let resp = client.issue(req).await.unwrap(); println!("{}", resp.body());	Test	Doc		Browser, Node.js, and Deno. Also native	JS `fetch` Interop using wasm-bindgen
http-client	use http_client::HttpClient; use http_types::{Method, Request}; use http_client::wasm::WasmClient as Client; let client = Client::new(); let req = Request::new(Method::Get, "https://httpbin.org/anything"); client.send(req).await.unwrap(); dbg!(client);	Example	Doc		Browser, Node.js, and Deno Also native (and others).	JS `fetch` Interop using wasm-bindgen
Gloo's gloo-net	use gloo_net::http::Request; let resp = Request::get("https://httpbin.org/anything").send() .await.unwrap();	yew's demo Test yew's tutorial	Doc	Demo _source	Browser, Node.js, and Deno	JS `fetch` Interop using wasm-bindgen
Iced	// uses reqwest let txt = reqwest::get("https://httpbin.org/anything") .await?.text().await?; log::info!("text: {}", txt);	Example 1 Example 2 Example 3			Browser	Has no built-in solutions, just uses any suitable 3rd-party lib, such as: reqwest.
Leptos	// uses reqwasm or gloo_net for CSR use leptos_dom::logging::console_log; let txt = reqwasm::http::Request::get( "https://httpbin.org/anything") .send().await?.text().await?; console_log(txt.as_str());	Example using reqwasm Example using gloo_net Example using reqwest for SSR			Browser Also server-side rendering (SSR)	Has no built-in solutions, just uses any suitable 3rd-party lib, such as: reqwest, gloo_net, reqwasm.
localghost	use localghost::prelude::*; use localghost::{log, net}; let res = net::Request::get( "https://httpbin.org/anything").send().await?; log::info!("text: {:?}", res.body_string().await?);	Example Example	Doc		Browser and maybe Node	JS `fetch` Interop using wasm-bindgen
MoonZoon	use zoon::{println, *}; let txt = reqwest::get("https://httpbin.org/anything") .await? .error_for_status()? .text() .await?; println!("text: {}", txt);	Example	Doc		Browser	Has no built-in solutions, just uses any suitable 3rd-party lib, such as: reqwest.
quad-net _{Plugin for miniquad and macroquad}	use quad_net::http_request::RequestBuilder; let mut request = RequestBuilder::new( "https://httpbin.org/anything").send(); loop { if let Some(data) = request.try_recv() { info!("Done! {}", data.unwrap()); } next_frame().await; }	Example	Some Readme	Demo Dev Container	Browser	JS `XMLHttpRequest` interop in the imported host function.
reqwest	let txt = reqwest::get("https://httpbin.org/anything") .await?.text().await?; println!("Text: {:?}", txt);	Example Example	Doc		Browser, Node.js, and Deno Also native	JS `fetch` Interop using wasm-bindgen
reqwasm	use reqwasm::http::Request; let resp = Request::get("https://httpbin.org/anything").send() .await.unwrap();	Example	Doc		Browser, Node.js, and Deno	Wrapper for gloo_net
sauron	use sauron::dom::{Http, spawn_local}; spawn_local(async move { let txt = Http::fetch_text( "https://httpbin.org/anything").await.unwrap(); log::trace!("{}", txt); });	Example Example for component	Doc		Browser Also server-side rendering (SSR)	JS `fetch` interop using wasm-bindgen
Seed	use seed::{prelude::, }; let response = fetch("https://httpbin.org/anything").await?; let body = response.text().await?;	Example	Doc Doc		Browser, Node.js, and Deno	JS `fetch` interop using wasm-bindgen
surf	let mut resp = surf::get("https://httpbin.org/anything").await?; println!("{}", resp.body_string().await?);	Example	Doc		Browser, Node.js, and Deno Also native	Uses http-rs/http-client as WASM backend
sycamore	// uses reqwasm use reqwasm::http::Request; let url = "https://httpbin.org/anything"; let res = Request::get(&url).send().await?; let txt = res.text().await?; log::info!("{}", txt);	Example Example for Builder API			Browser	Has no built-in solutions, just uses any suitable 3rd-party lib, such as: reqwasm.

Scripting languages for Rust

Product / Implementation	TLDR: Usage	TLDR: Example code	Doc	Online demo	WASM Runtime	Internals: method to do real request
Rune	let req = http::get( "https://httpbin.org/anything").await?; let txt = req.text().await?; println(txt);	Async example Stream example Json example	Some doc	Playground	Browser	Uses reqwest.

Starlark

Product / Implementation	TLDR: Usage	TLDR: Example code	Doc	Online demo	WASM Runtime	Internals: method to do real request
starlark-go	# custom function print(httpget('https://httpbin.org/anything'))	Example	Readme	Demo Dev Container	Browser, Bun, and Deno.	Using Golang's `"net/http"` via mapping a custom function inside Starlark.
starlark-go-nethttp	res = http.get('https://httpbin.org/anything') print(res.body)	Test Example	Readme	Demo Dev Container	Browser, Bun, and Deno.	Using Golang's `"net/http"` via mapping.
qri-io/starlib _{"Starlark's missing stdlib"}	load('http.star', 'http') res = http.get('https://httpbin.org/anything') print(res.body())	Test Example	Doc	Demo Dev Container	Browser, Bun, and Deno.	Using Golang's `"net/http"` via mapping.
starlight-go/starlight	# custom function print(httpget('https://httpbin.org/anything'))	Example	Readme	Demo Dev Container	Browser, Bun, and Deno.	Using Golang's `"net/http"` via mapping a custom function inside Starlark.
Starlight Enhanced _{Maintained fork of Starlight}	# custom function print(httpget('https://httpbin.org/anything'))	Example	Readme	Demo Dev Container	Browser, Bun, and Deno.	Using Golang's `"net/http"` via mapping a custom function inside Starlark.

Swift

Product / Implementation TLDR: Usage TLDR: Example code Doc Online demo WASM Runtime Internals: method to do real request

SwiftWasm

import JavaScriptEventLoop
import JavaScriptKit

JavaScriptEventLoop.installGlobalExecutor()

let fetch = JSObject.global.fetch.function!
let resp = try! await JSPromise(
  fetch("https://httpbin.org/anything").object!)!.value
let text = try! await JSPromise(resp.text().object!)!.value
print(text)

Example 1
Example 2
Example 3 from Tokamak

Browser, Node.js, and Deno

Direct fetch interop using JavaScriptKit framework

Tcl

Product / Implementation	TLDR: Usage	TLDR: Example code	Doc	Online demo	WASM Runtime	Internals: method to do real request
criTiCaL	# custom command puts [httpget "https://httpbin.org/anything"]	Example	Readme	Demo Dev Container	Browser, Bun, and Deno.	Uses Golang's `"net/http"` in a custom command injected into the language.
Wacl	set func_ptr_number 2 puts [::wacl::jscall $func_ptr_number "string" "string" "https://httpbin.org/anything"] Needs a JavaScript-side function registered using `jswrap()`: wacl.onReady(function (interpreter) { const wrappedFuncName = interpreter.jswrap(function (ptrUrl) { const url = interpreter.ptr2str(ptrUrl); const xhr = new XMLHttpRequest(); xhr.open('GET', url, false); xhr.send(); return interpreter.str2ptr(xhr.responseText); }, 'string', 'string'); });	Example `jswrap` example	Readme	Demo / Playground	Browser	Manual JS `XMLHttpRequest` interop by registering a function on JS side using `jswrap()` via Emscripten `addFunction()` API and then calling it using `::wacl::jscall` by its registration number.

Wonkey

Product / Implementation	TLDR: Usage	TLDR: Example code	Doc	Online demo	WASM Runtime	Internals: method to do real request
Wonkey/httprequest	Local request := New HttpRequest request.ReadyStateChanged = Lambda() If request.ReadyState = ReadyState.Done Then Print "Body: " + request.ResponseText End End request.Open("GET", "https://httpbin.org/anything") request.Send()	Example 1 Example 2	Some doc	Demo Dev Container	Browser	JS `fetch` interop using Emscripten APIs.

Standalone and server-side runtimes (mostly WASI and WASI-Socket-enabled), incl containers, FaaS, Edge Computing, etc

AssemblyScript

Product / Implementation TLDR: Usage TLDR: Example code Doc Online demo WASM Runtime Internals: method to do real request

wasi-http

_{implementations:}

import { Console } from "as-wasi/assembly";
import { request } from "./request";
export function cabi_realloc(a: usize, b: usize,
                             c: usize, len: usize): usize {
 return heap.alloc(len);
}

let response = request("GET", "https://httpbin.org/anything", null,
  [{ name: "User-Agent", value: "wasi-http" }]);

Console.log(response.Body);

Example

Readme

Dev Container by brendandburns

Wasmtime version 9.0 and above.
Wazero in wasi-go version 0.7 and above

Calling to imported

Wasmtime's host function, which, in turn, performs real request using hyper: https, http.
Wazero's host function, which performs a request using "net/http".

C# / .Net

Product / Implementation TLDR: Usage TLDR: Example code Doc Online demo WASM Runtime Internals: method to do real request

Extism Plug-in Development Kit (PDK) for .NET

using Extism;

var req = new HttpRequest(
    "https://httpbin.org/anything")
{
    Method = HttpMethod.GET
};
var res = Pdk.SendRequest(req);
Pdk.SetOutput(res.Body);

Doc

Dev Container

Extism uses Wasmtime
Extism CLI uses Wazero

Calling C-level-imported runtime's host function exported for plugins, which makes actual request using ureq.

Spin SDK for .NET

using Fermyon.Spin.Sdk;
using System.Net;

var req = new HttpRequest { Url = "https://httpbin.org/anything" };
var resp = HttpOutbound.Send(req);

Example

Doc

Spin (uses Wasmtime)

C level binding to
Spin's host function.

wasi-http

_{implementations:}

// *Still* identical to wasi-experimental-http's code. 
using Wasi.Http;

var client = new HttpClient(new WasiHttpHandler());
var result = await client.GetAsync("https://httpbin.org/anything", 
 System.Threading.CancellationToken.None);
var content = await result.Content.ReadAsStringAsync();
Console.WriteLine(content);

Example

Readme

Dev Container by brendandburns

Wasmtime version 9.0 and above.
Wazero in wasi-go version 0.7 and above

_{Sequence: .Net -> C -> WASI}

Calling imported C-level Mono binding which calls generated (_{by wit-bindgen from the wit template}) code, which calls imported

Wasmtime's host function, which, in turn, performs real request using hyper: https, http.
Wazero's host function, which performs a request using "net/http".

C / C++

Product / Implementation TLDR: Usage TLDR: Example code Doc Online demo WASM Runtime Internals: method to do real request

Extism Plug-in Development Kit (PDK) for C

#define EXTISM_IMPLEMENTATION
#include "extism-pdk.h"
#include <stdint.h>
#include <string.h>

int32_t EXTISM_EXPORTED_FUNCTION(httpget) {
  const char *r = "{\"url\": \"https://httpbin.org/anything\"}";
  ExtismHandle req = extism_alloc_buf_from_sz(r);
  ExtismHandle res = extism_http_request(req, 0);

  extism_output_set_from_handle(res, 0, extism_length(res));
  return 0;
}

Doc

Dev Container

Extism uses Wasmtime
Extism CLI uses Wazero

Calling C-level-imported runtime's host function exported for plugins, which makes actual request using ureq.

httpclient_wasmedge_socket

// no SSL support yet
std::array<char, 4096> buf{};
fetchIO *io = fetchGetURL("http://httpbin.org/anything", "4");
int nbytes = fetchIO_read(io, buf.data(), buf.size());
fetchIO_close(io);
std::cout << buf.data() << std::endl;

Example

WasmEdge

Raw socket write using WasmEdge Socket SDK for C/C++, which imports Wasmedge's implementation of WASI Socket

wasi-http

_{implementations:}

// snippet, expand it for full code
types_outgoing_request_t request = types_new_outgoing_request(
        &method, &path, &query, &scheme, &domain, headers);

response = default_outgoing_http_handle(request, NULL);

types_future_incoming_response_get(response, &result);

types_incoming_response_consume(result.val.ok, &stream);

streams_read(stream, len, &body_res, &err);

#include "proxy.h" // Generated by wit-bindgen
// from https://github.com/WebAssembly/wasi-http/tree/main/wit
#include <stdio.h>

void http_handle(uint32_t arg, uint32_t arg0) {}

int main() {
    types_headers_t headers = types_new_fields(NULL);
    types_method_t method = {.tag = TYPES_METHOD_GET};
    types_scheme_t scheme = {.tag = TYPES_SCHEME_HTTPS};
    proxy_string_t path, domain, query;
    proxy_string_set(&domain, "httpbin.org");
    proxy_string_set(&path, "/anything");
    proxy_string_set(&query, "");

    types_outgoing_request_t request = types_new_outgoing_request(
        &method, &path, &query, &scheme, &domain, headers);
    types_future_incoming_response_t response;

    response = default_outgoing_http_handle(request, NULL);

    proxy_result_incoming_response_error_t result;
    types_future_incoming_response_get(response, &result);

    types_incoming_stream_t stream;
    types_incoming_response_consume(result.val.ok, &stream);

    int32_t len = 16 * 1024;
    proxy_tuple2_list_u8_bool_t body_res;
    streams_stream_error_t err;
    streams_read(stream, len, &body_res, &err);

    printf("Response body: %s\n", body_res.f0.ptr);

    proxy_tuple2_list_u8_bool_free(&body_res);
    types_drop_outgoing_request(request);
    streams_drop_input_stream(stream);
    types_drop_incoming_response(result.val.ok);

    return 0;
}

Example

Readme

Dev Container by brendandburns

Wasmtime version 9.0 and above.
Wazero in wasi-go version 0.7 and above

Calling a function generated by wit-bindgen from the wit template, which calls the

Wasmtime's host function, which, in turn, performs real request using hyper: https, http.
Wazero's host function, which performs a request using "net/http".

Golang (Tinygo)

Product / Implementation	TLDR: Usage	TLDR: Example code	Doc	Online demo	WASM Runtime	Internals: method to do real request
Capsule	import ( hf "github.com/bots-garden/capsule/capsulemodule/hostfunctions" ) res, err := hf.Http("https://httpbin.org/anything", "GET", nil, "")	Example	HTTP request docs		wazero	wazero's Host Functions feature
Extism Plug-in Development Kit (PDK) for (Tiny)Go	import "github.com/extism/go-pdk" req := pdk.NewHTTPRequest("GET", "https://httpbin.org/anything") resp := req.Send() pdk.OutputMemory(resp.Memory())	Example	Doc		Extism uses Wasmtime	Calling C-level-imported runtime's host function exported for plugins, which makes actual request using `ureq`.
knqyf263/go-plugin	hostFunctions := protobufs.NewHostFunctions() resp, err := hostFunctions.HttpGet(ctx, &protobufs.HttpGetRequest{Url: "https://httpbin.org/anything"})	Example Example Usage from host program	Readme	Dev Container	go-plugin uses wazero	Invoking the bound host function.
Spin SDK for (Tiny)Go	import ( spinhttp "github.com/fermyon/spin/sdk/go/http" ) resp, err := spinhttp.Get("https://httpbin.org/anything")	Example 1 Example 2	Doc Doc		Spin (uses Wasmtime)	C level binding to Spin's host function.
wasi-http _{implementations:} wasmtime-wasi-http dispatchrun/wasi-go	import ( "io/ioutil" "net/http" wasiclient "github.com/dev-wasm/dev-wasm-go/client" ) client := http.Client{ Transport: wasiclient.WasiRoundTripper{}, } response, err := client.Get("https://httpbin.org/anything") defer response.Body.Close() body, err := ioutil.ReadAll(response.Body) if err == nil { println(string(body)) }	Example	Readme	Dev Container by brendandburns _{needs plenty of RAM to compile (~4G), so may cause OOM on 2-core instance}	Wasmtime version 9.0 and above. Wazero in wasi-go version 0.7 and above	_{Sequence: Go -> C -> WASI} Calling a method generated by `wit-bindgen` from the wit template. That method calls the generated C-level-bound function, which calls the imported Wasmtime's host function, which, in turn, performs real request using `hyper`: https, http. Wazero's host function, which performs a request using `"net/http"`.
wasi-http-go	import ("io"; "log"; "net/http" _ "github.com/ydnar/wasi-http-go/wasihttp" ) req, _ := http.NewRequest("GET", "https://httpbin.org/anything", http.NoBody) resp, _ := http.DefaultClient.Do(req) defer resp.Body.Close() body, _ := io.ReadAll(resp.Body) log.Println(string(body))	Example	How to run	Dev Container	Runtime supporting wasip2-http (only Wasmtime at the moment)	Wrapper for wasi-http using overrides.
dispatchrun/net _{f.k.a. stealthrocket/net}	import ( "fmt" ; "io" ; "net/http" _ "github.com/dispatchrun/net/http" ) response, err := http.Get("http://httpbin.org/anything") if err != nil { fmt.Println(err) } defer response.Body.Close() body, err := io.ReadAll(response.Body) if err == nil { fmt.Println(string(body)) }	Test HTTP Example HTTPS Example	Readme	Dev Container	Wazero and WasmEdge	Hotpatching on module import `http.DefaultTransport` with `wasip1.DialContext` which refers to imported `sock_conn()` in the case of WasmEdge and to `syscall.Connect()` in the case of Wazero.
VMware OCTO / Wasm Workers Server	import ( "log"; "net/http" "github.com/vmware-labs/wasm-workers-server/kits/go/worker" ) req, _ := http.NewRequest(http.MethodGet, "https://httpbin.org/anything", nil) res, _ := worker.SendHttpRequest(req) defer res.Body.Close() body, _ := io.ReadAll(res.Body) log.Println(string(body))	Example	Doc		Wasm Workers Server uses Wasmtime	Calling to Go-wrapped, to C-wrapped, to C-level imported host function which makes request using reqwest.

Haskell

Product / Implementation	TLDR: Usage	TLDR: Example code	Doc	Online demo	WASM Runtime	Internals: method to do real request
Extism Plug-in Development Kit (PDK) for Haskell	module Main where import Extism.PDK import Extism.PDK.HTTP https_get = do let url = "https://httpbin.org/anything" let req = newRequest url resp <- sendRequest req Nothing outputMemory (memory resp) foreign export ccall "https_get" https_get :: IO () main = https_get	Example	Doc		Extism uses Wasmtime	Calling imported runtime's host function exported for plugins, which makes actual request using `ureq`.

Java

Product / Implementation

TLDR: Usage

TLDR: Example code

Doc

Online demo

WASM Runtime

Internals: method to do real request

dicej/spin-teavm-example

Uses forked TeaVM as compiler.

import wit_wasi_outbound_http.WasiOutboundHttp.*;

Result<Response, HttpError> result =
  WasiOutboundHttp.request(
    new Request(Method.GET, "https://httpbin.org/anything", 
    new ArrayList<>(), new ArrayList<>(), null));

Response resp = result.getOk();
String body = new String(resp.body, UTF_8);

Example

Readme

Spin (uses Wasmtime)

Direct invocation of imported Spin's host function.

JavaScript and TypeScript

Product / Implementation	TLDR: Usage	TLDR: Example code	Doc	Online demo	WASM Runtime	Internals: method to do real request
wasmedge-quickjs	import { fetch } from 'http' const res = await fetch('https://httpbin.org/anything') print(await res.text())	Example Example for http	Doc	Dev Container	WasmEdge	Distinguished by URL scheme raw socket write to (1) `WasiTcpConn` which is wrapper to Wasmedge's implementation of WASI Socket or (2) `WasiTlsConn` which is wrapper to `wasmedge_rustls_api`.
Extism Plug-in Development Kit (PDK) for JavaScript	function https_get() { let resp = Http.request( { url: 'https://httpbin.org/anything', method: 'GET', headers: { 'User-Agent': 'extism_pdk' } }, null ); Host.outputString(resp.body); } module.exports = { https_get }	Example	Some doc		Extism uses Wasmtime	`Http` object injected into QuickJS's global namespace. It calls the `http::request()` from Extism PDK for Rust.
Spin SDK for JavaScript	const resp = await fetch('https://httpbin.org/anything'); const decoder = new TextDecoder('utf-8'); const body = decoder.decode(await resp.arrayBuffer());	Example	Doc Doc		Spin (uses Wasmtime)	Invocation of bound JS SDK function, which calls via Rust Spin SDK Spin's host function.
Spin SDK for TypeScript	const resp = await fetch('https://httpbin.org/anything'); const body = await resp.text();	Example	Doc Doc		Spin (uses Wasmtime)	Invocation of bound JS SDK function, which calls via Rust Spin SDK Spin's host function.
VMware OCTO / Wasm Workers Server	const resp = await fetch('https://httpbin.org/anything'); const txt = await resp.text(); console.log(txt);	Example	Doc		Wasm Workers Server uses Wasmtime	Calling bound to JS `send_http_request()` the host function which makes request using reqwest.

MoonBit

Product / Implementation TLDR: Usage TLDR: Example code Doc Online demo WASM Runtime Internals: method to do real request

Extism Plug-in Development Kit (PDK) for MoonBit

_Experimental

pub fn https_get() -> Int {
  let req : Unit = @http.new_request(
    @http.Method::GET,
    "https://httpbin.org/anything",
  )
  let resp : Unit = req.send()
  resp.output()
  return 0
}

Doc
Readme

Extism uses Wasmtime
Extism CLI uses Wazero

Calling imported runtime's host function exported for plugins, which makes actual request using ureq.

Prolog

Product / Implementation TLDR: Usage TLDR: Example code Doc Online demo WASM Runtime Internals: method to do real request

trealla-spin

_{Spin SDK for Prolog}

:- use_module(library(spin)).

http_fetch("https://httpbin.org/anything", Resp, []),
write(Resp), nl.

Example

Doc

Dev Container

Spin (uses Wasmtime)

Invoking wasi-outbound-http by binding to http_fetch predicate.

Python

Product / Implementation TLDR: Usage TLDR: Example code Doc Online demo WASM Runtime Internals: method to do real request

componentize-py

import poll_loop
from proxy.imports.types import (
  SchemeHttps, OutgoingRequest )

req = OutgoingRequest(Fields.from_list([]))
req.set_scheme(SchemeHttps())
req.set_authority('httpbin.org')
req.set_path_with_query('/anything')

resp = await poll_loop.send(req)

stream = poll_loop.Stream(resp.consume())
buf = b''
while True:
  chunk = await stream.next()
  if chunk is None:
    break
  else:
    buf += chunk

print(buf.decode('utf-8'))

Example

Readme

Wasmtime version 15.0, maybe incl. Spin.

Genetaring Python bindings to wasi-http based on wit files under the scenes during componentize process.

Extism Plug-in Development Kit (PDK) for Python

import extism

@extism.plugin_fn
def httpget():
  res = extism.Http.request(
    'https://httpbin.org/anything')
  extism.output_str(res.data_str())

Example

Readme

Dev Container

Extism uses Wasmtime
Extism CLI uses Wazero

Http.request() method calls the FFI function injected into Python's "native" ffi module. It calls the http::request() from Extism PDK for Rust.

Spin SDK for Python

from spin_http import Request, http_send

response = http_send(
  Request('GET', 
  'https://httpbin.org/anything', 
  {}, None))

print(str(response.body, 'utf-8'))

Example

Doc
Doc

Spin (uses Wasmtime)

A Python spin_http module calls imported via Rust Spin SDK Spin's host function.

Rust

Product / Implementation	TLDR: Usage	TLDR: Example code	Doc	Online demo	WASM Runtime	Internals: method to do real request
Extism Plug-in Development Kit (PDK) for Rust	use extism_pdk::*; #[plugin_fn] pub fn https_get(_: ()) -> FnResult<Memory> { let req = HttpRequest::new("https://httpbin.org/anything"); let resp = http::request::<()>(&req, None)?; Ok(resp.into_memory()) }	Example Example	Doc Doc	Possible with Dev Container by brendandburns	Extism uses Wasmtime Extism CLI uses Wazero	Calling C-level-imported runtime's host function exported for plugins, which makes actual request using `ureq`.
http_req_wasi	use http_req::request; let mut writer = Vec::new(); let res = request::get("https://httpbin.org/anything", &mut writer).unwrap(); println!("body: {}", String::from_utf8_lossy(&writer));	Example	Doc		WasmEdge	Writes to `wasmedge_wasi_socket` stream. For SSL, the stream is wrapped with rustls's stream.
Spin SDK for Rust	let mut res = spin_sdk::http::send( http::Request::builder() .method("GET") .uri("https://httpbin.org/anything") .body(None)?, )?;	Example 1 Example 2 Example 3 _{(uses alias)}	Doc Doc Doc		Spin (uses Wasmtime)	Calling imported Spin's host function.
reqwest_wasi as part of WasmEdge Sockets Any code based on WasmEdge's forks of tokio-rs or mio is expected to work in Wasmedge runtime	let res = reqwest::get("https://httpbin.org/anything").await?; let body = res.text().await?; println!("text: {}", body);	Example	Doc Doc		WasmEdge	Wrapping internal stream with WasmEdgeTls, which is built on top of WasmEdge's implementation of WASI Socket.
Waki _{new gen of wasi-http-client}	use waki::Client; let res = Client::new() .get("https://httpbin.org/anything") .send().unwrap(); let body = String::from_utf8( res.body().unwrap()).unwrap(); println!("body:{}", body);	Example	Some doc	Dev Container	Wasmtime version 17 and above	Uses imported wasmtime-wasi-http.
wasi-http _{implementations:} wasmtime-wasi-http dispatchrun/wasi-go	let headers = types::new_fields(&[("User-agent", "WASI-HTTP")]); let request = types::new_outgoing_request( types::MethodParam::Get, "/anything", "", Some(types::SchemeParam::Https), "httpbin.org", headers, ); let future_response = default_outgoing_http::handle(request, None); types::drop_outgoing_request(request); let response = types::future_incoming_response_get(future_response) .ok_or_else(\|\| anyhow!("response is available immediately"))? .map_err(\|err\| anyhow!("response error: {err:?}"))?; types::drop_future_incoming_response(future_response); let stream = types::incoming_response_consume(response) .map_err(\|()\| anyhow!("response has no body stream"))?; let mut body = Vec::new(); let mut is_eof = false; while !is_eof { let (mut chunk, stream_at_end) = streams::read(stream, u64::MAX)?; is_eof = stream_at_end; body.append(&mut chunk); } streams::drop_input_stream(stream); types::drop_incoming_response(response); println!("body: {}", str::from_utf8(&body).unwrap());	Example	Readme	Possible with Dev Container by brendandburns	Wasmtime version 9.0 and above. Wazero in wasi-go version 0.7 and above	Rust code generated (_{by wit-bindgen from the wit template}) calls imported Wasmtime's host function, which, in turn, performs real request using `hyper`: https, http. Wazero's host function, which performs a request using `"net/http"`.
VMware OCTO / Wasm Workers Server	let req = Request::builder() .uri("https://httpbin.org/anything") .body(String::new()).unwrap(); let res = bindings::send_http_request(req).unwrap(); let data = res.body(); let txt = String::from_utf8_lossy(&data); println!("text: {txt}");	Example	Doc		Wasm Workers Server uses Wasmtime	Calling imported host function which makes request using reqwest.

Virgil

Product / Implementation	TLDR: Usage	TLDR: Example code	Doc	Online demo	WASM Runtime	Internals: method to do real request
Extism Plug-in Development Kit (PDK) for Virgil	var req = Http.newRequest(Method.GET, "https://httpbin.org/anything"); def res = req.send(null); res.output();	Example	Readme		Extism uses Wasmtime Extism CLI uses Wazero	Calling C-level-imported runtime's host function exported for plugins, which makes actual request using `ureq`.

Zig

Product / Implementation TLDR: Usage TLDR: Example code Doc Online demo WASM Runtime Internals: method to do real request

Extism Plug-in Development Kit (PDK) for Zig

const std = @import("std");
const extism_pdk = @import("extism-pdk");
const allocator = std.heap.wasm_allocator;

export fn https_get() i32 {
const plugin = extism_pdk.Plugin.init(allocator);
var req = extism_pdk.http.HttpRequest.init(allocator, "GET", 
  "https://httpbin.org/anything");
defer req.deinit();
req.setHeader("User-Agent", "extism_pdk") catch unreachable;

const resp = plugin.request(req, null) catch unreachable;
defer resp.deinit();

plugin.outputMemory(resp.memory);
return 0;
}

Example

Some doc

Extism uses Wasmtime

Calling imported runtime's host function exported for plugins, which makes actual request using ureq.

Spin SDK for Zig

_Unofficial
_{Fork of deleted orig repo}

const spin = @import("spin");

const req = spin.http.Request{ .method = .GET, 
  .url = "https://httpbin.org/anything" };
const res = spin.http.send(req) catch unreachable;

Example

Spin (uses Wasmtime)

Calling to C-level import of Spin's host function.

Firefox 120+, and all based on Chrome(ium) 119+. ↩ ↩² ↩³ ↩⁴ ↩⁵ ↩⁶ ↩⁷ ↩⁸

Name		Name	Last commit message	Last commit date
Latest commit History 115 Commits
ARCHIVE.md		ARCHIVE.md
LICENSE		LICENSE
README.md		README.md

License

vasilev/HTTP-request-from-inside-WASM

Folders and files

Latest commit

History

Repository files navigation

Make HTTP request from inside WebAssembly

Contents

Browser WASM runtimes and V8-based runtimes like Node.js and Deno, also Bun

Ada

AssemblyScript

BASIC

Berry

C#

C / C++

Crystal

Dart

Expression evaluation languages

Forth

Golang

Golang-like languages

Java / JVM

JavaScript

Using browser's own JavaScript VM

Libraries to use from JavaScript

JavaScript VM or interpreter compiled to WASM

JavaScript built with Emscripten

JavaScript implemented in .NET

JavaScript implemented in Golang

Kotlin

Lisp

Clojure-like languages

Lua

Lua implemented in Golang

Lua dialects

PHP

Pascal

Perl

Prolog

Prolog implemented in Golang

Python

Python-like languages

R

Rebol

Rebol-like languages

Ruby

Rust

Scripting languages for Rust

Starlark

Swift

Tcl

Wonkey

Standalone and server-side runtimes (mostly WASI and WASI-Socket-enabled), incl containers, FaaS, Edge Computing, etc

AssemblyScript

C# / .Net

C / C++

Golang (Tinygo)

Haskell

Java

JavaScript and TypeScript

MoonBit

Prolog

Python

Rust

Virgil

Zig

Footnotes

About

Topics

Resources

License

Uh oh!

Stars

Watchers

Forks