Call an external API from a FastEdge app

FastEdge applications can make outbound HTTP calls from inside the handler — reach out to any external service, transform the response, and return the result to the caller. This guide builds an application that fetches a list of users from a public REST API and returns the first five as JSON. It assumes the toolchain is already configured for the chosen language.

Handler

Create a new library crate or project, then write the handler for the chosen language.

Modern Rust
Legacy Rust
JavaScript

Create a library crate and replace Cargo.toml:

cargo new --lib outbound-fetch
cd outbound-fetch

[package]
name = "outbound_fetch"
version = "0.1.0"
edition = "2021"

[lib]
crate-type = ["cdylib"]

[dependencies]
wstd = "0.6"
anyhow = "1"
serde_json = "1"

Replace src/lib.rs:

use anyhow::anyhow;
use wstd::http::body::Body;
use wstd::http::{Client, Request, Response};
use serde_json::{json, Value};

#[wstd::http_server]
async fn main(_request: Request<Body>) -> anyhow::Result<Response<Body>> {
    let upstream_req = Request::get("https://jsonplaceholder.typicode.com/users")
        .body(Body::empty())
        .map_err(|e| anyhow!("failed to build request: {e}"))?;

    let client = Client::new();
    let upstream_resp = client
        .send(upstream_req)
        .await
        .map_err(|e| anyhow!("upstream request failed: {e}"))?;

    let (_, mut body) = upstream_resp.into_parts();
    let body_bytes = body.contents().await?;

    let users: Value = serde_json::from_slice(body_bytes)?;
    let sliced = match users.as_array() {
        Some(arr) => Value::Array(arr.iter().take(5).cloned().collect()),
        None => Value::Array(vec![]),
    };
    let count = sliced.as_array().map(|a| a.len()).unwrap_or(0);

    Ok(Response::builder()
        .status(200)
        .header("content-type", "application/json")
        .body(Body::from(json!({ "count": count, "users": sliced }).to_string()))?)
}

Client::new() routes requests through the WASI outbound-http interface — the host runtime handles the actual network call. The await on client.send() is real async: the handler yields while the upstream request is in flight. The response body arrives as a stream; body.contents().await reads it fully into memory before parsing. Every ? propagates errors through anyhow::Result — FastEdge converts a handler returning Err into a 500 response, with the error message written to application logs.

Create a library crate and replace Cargo.toml:

cargo new --lib outbound-fetch
cd outbound-fetch

[package]
name = "outbound_fetch"
version = "0.1.0"
edition = "2021"

[lib]
crate-type = ["cdylib"]

[dependencies]
fastedge = "0.4"
anyhow = "1"
serde_json = "1"

Replace src/lib.rs:

use fastedge::body::Body;
use fastedge::http::{Method, Request, Response, StatusCode};
use serde_json::{json, Value};

#[fastedge::http]
fn main(_req: Request<Body>) -> anyhow::Result<Response<Body>> {
    let upstream_req = Request::builder()
        .method(Method::GET)
        .uri("https://jsonplaceholder.typicode.com/users")
        .body(Body::empty())?;

    let upstream_resp = fastedge::send_request(upstream_req)?;

    let body = upstream_resp.into_body();
    let users: Value = serde_json::from_slice(&body)?;
    let sliced = match users.as_array() {
        Some(arr) => Value::Array(arr.iter().take(5).cloned().collect()),
        None => Value::Array(vec![]),
    };
    let count = sliced.as_array().map(|a| a.len()).unwrap_or(0);

    Ok(Response::builder()
        .status(StatusCode::OK)
        .header("content-type", "application/json")
        .body(Body::from(json!({ "count": count, "users": sliced }).to_string()))?)
}

fastedge::send_request() is a synchronous blocking call — the handler waits until the full upstream response arrives. The response body is immediately available as a byte slice via into_body(), with no streaming step needed. Every ? propagates errors through anyhow::Result — FastEdge converts a handler returning Err into a 500 response, with the error message written to application logs.

Create a project directory and install the SDK:

mkdir outbound-fetch
cd outbound-fetch
npm init -y
npm pkg set type=module
npm install @gcoredev/fastedge-sdk-js
mkdir src wasm

Create src/index.js:

addEventListener('fetch', async (event) => {
  const response = await fetch('https://jsonplaceholder.typicode.com/users');
  const users = await response.json();
  const sliced = users.slice(0, 5);
  event.respondWith(new Response(JSON.stringify({ count: sliced.length, users: sliced }), {
    headers: { 'content-type': 'application/json' },
  }));
});

The handler is async — await fetch(...) makes an outbound HTTP call through the WASI outbound-http interface, and await response.json() reads and parses the response body. The fetch API behaves the same way here as in a browser or Node.js environment: returning a Response object with familiar methods like .json(), .text(), and .arrayBuffer(). If the upstream call fails, the unhandled rejection produces a 500 response with the error written to application logs.

Build

Compile the handler to a WebAssembly binary.

Modern Rust
Legacy Rust
JavaScript

cargo build --release --target wasm32-wasip2

The binary is at ./target/wasm32-wasip2/release/outbound_fetch.wasm.

cargo build --release --target wasm32-wasip1

The binary is at ./target/wasm32-wasip1/release/outbound_fetch.wasm.

npx fastedge-build --input src/index.js --output wasm/app.wasm

The binary is at ./wasm/app.wasm.

Deploy

The outbound call happens on every request, from every edge node that handles traffic for this app. For data that changes infrequently, storing the upstream response in a KV store eliminates per-request latency after the first fetch.

​Handler

​Build

​Deploy

Handler

Build

Deploy