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.

Contents

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+. ↩ ↩² ↩³ ↩⁴ ↩⁵ ↩⁶ ↩⁷ ↩⁸

License

vasilev/HTTP-request-from-inside-WASM

ErrorLooks like something went wrong!

About

Topics

Resources

License

Uh oh!

Stars

Watchers

Forks

Error
Looks like something went wrong!