Home
Developers
Making Outbound Requests from the Edge

Making Outbound Requests from the Edge

By Gcore

August 26, 2026

2 min read

Conceptual diagram illustrating an Edge Worker connecting databases, code, cloud, and analytics.

FastEdge workers aren't limited to just responding to incoming requests — they can also make outbound network requests to external services. This opens up a world of possibilities: aggregating data from multiple APIs, proxying requests to upstream services, fetching remote content for caching, and more.

This post covers Making Outbound Requests from the Edge — a fundamental pattern for any edge application that needs to communicate with external services.

How It Works

Fetch data from external APIs from your FastEdge worker. Patterns for aggregation, caching, and error handling.

The FastEdge Rust SDK provides two approaches for making outbound requests:

Synchronous (fastedge::http_client) — simple, blocking API that works within the standard Request/Response handler model. Best for straightforward fetch-and-return scenarios.
Asynchronous (proxy-wasm dispatch) — uses the proxy-wasm ABI to pause request processing, make an HTTP call, and resume. Best for intercepting and augmenting client requests with external data.

Approach 1: Synchronous HTTP Client

The simplest approach — build a Request, send it, and get a Response back:

use fastedge::{ body::Body, http::{Request, Response, StatusCode, Error}, http_client, }; #[fastedge::http] fn main(req: Request<Body>) -> Result<Response<Body>, Error> { // Build an outbound request to an external API let upstream = Request::builder() .method("GET") .uri("https://httpbin.org/ip") .header("User-Agent", "fastedge-worker") .header("Accept", "application/json") .body(Body::empty()) .map_err(|_| Error::InvalidBody)?; // Send it from the edge let resp = http_client::send_request(upstream)?; // Forward the upstream response headers plus our own let status = resp.status(); let body = resp.into_body(); Response::builder() .status(status) .header("content-type", "application/json") .header("x-edge-cached", "false") .body(body) }

Approach 2: Async Proxy-Wasm Dispatch

For more advanced scenarios where you need to intercept a client request and augment it with external data:

use fastedge::proxywasm::*; use std::time::Duration; struct MyHttp { state: u32, } impl Context for MyHttp {} impl HttpContext for MyHttp { fn on_http_request_headers( &mut self, _: usize, _: bool, ) -> Action { // Already got the data, continue the request if self.state == 1 { return Action::Continue; } // Pause the client request and fetch external data match self.dispatch_http_call( "api.example.com", // authority vec![ // headers (":scheme", "https"), (":authority", "api.example.com"), (":path", "/auth/check"), ("Authorization", "Bearer token123"), ], None, // no body vec![], // no trailers Duration::from_secs(5), // timeout ) { Ok(token) => Action::Pause, Err(status) => { self.send_http_response( 502, vec![], b"Upstream unavailable", ); Action::Pause } } } fn on_http_call_response( &mut self, token_id: u32, num_headers: usize, body_size: usize, _: usize, ) { if num_headers > 0 { let body = self.get_http_call_response_body(0, body_size); // Store the response data and resume the client request self.state = 1; self.resume_http_request(); } else { // HTTP call failed, reset self.reset_http_request(); } } }

Common Use Cases

API aggregation — fetch data from multiple upstream APIs and combine it into a single response.
Authentication — validate tokens against an external authentication service before allowing access.
Content caching — fetch remote content on the first request and cache it at the edge for subsequent requests.
Proxying — act as a reverse proxy with additional processing, such as header injection or body transformation.
Webhook forwarding — receive webhooks at the edge and forward them to multiple downstream services.

Error Handling and Timeouts

Outbound HTTP calls are subject to network conditions. Always handle failures gracefully:

match http_client::send_request(upstream) { Ok(resp) => handle_success(resp), Err(e) => { logging::error!("Upstream call failed: {}", e); // Return a cached or fallback response instead of failing Response::builder() .status(StatusCode::OK) .header("content-type", "text/plain") .header("x-fallback", "true") .body(Body::from( "Service temporarily unavailable" )) } }

Caveat: Outbound requests from edge workers are subject to provider-configured timeouts, typically 5–30 seconds depending on your plan. Plan for failures with retries, circuit breakers, and fallback responses. Never assume an outbound call will succeed.

Visualizing image file size reduction from 2.4MB to 320KB through an optimization process.

On-the-fly Image Optimization at the Edge

Running compute at the edge means you can transform and optimize content before it reaches your users — with sub-millisecond cold starts and no additional infrastructure. Every FastEdge worker runs on WebAssembly, providing sandboxed, predi

Digital panel with lightning bolt icon, emitting orange data streams or energy.

Manipulating Headers at the Edge

Security at the edge means threats are stopped before they reach your infrastructure. By implementing security logic in FastEdge workers, you can validate, filter, and block requests at the closest edge location to the user — providing the

Central server distributes data through a network to multiple connected devices like laptops and phones.

Leverage Redis-Compatible Cache at the Edge

Glowing orange shield icon with a checkmark, symbolizing digital security and protection.

JWT Auth Gateway at the Edge

Diagram showing GraphQL input, a central processing hub, database interaction, and two successful outputs.

GraphQL Proxy and Caching at the Edge

Orange lines illustrate a global network connecting a central point to various distributed applications.

GeoIP Redirect — Route by Location

One of the most powerful features of edge computing is the ability to inspect and route traffic before it ever reaches your origin server. FastEdge gives you full programmatic control over request routing at every edge location worldwide.In

CDN

DNS

Streaming

Fast Edge

Image Optimization

AI Inference

GPU Cloud

AI Cloud

Everywhere AI

Gclaw

Compute

Storage

Containers

Databases

Cloud Networking

Hosting

Colocation

WAF

DDoS Protection

Bot Management

API Security

How Microsoft scaled global content delivery

How ProSieben scaled GNTM's app TOPSHOT

How Higgsfield scaled AI video generation

How Fawkes Games stopped DDoS attacks

Gaming

Media & Streaming

Ecommerce & Retail

ERP Hosting

Fintech

Hosting Providers

Ecommerce Agencies

Online Education

iGaming

Dynamic Web Acceleration

Global Content Delivery

Multi-CDN Resilience

Live Streaming at Scale

Secure Cloud Computing

Cloud Migration

Bot Protection

Online Events

Digital Sovereignty

Using Gcore

Docs

API

Developer Tools

Insights

Blog

Case studies

Reports

Community

Events

Startup Program

Discord

Help

Help center

Support

Changelog

Service Status

Gcore status page

Meet Gcore

About us

Contact Us

Press

Press

Awards

Inside Gcore

Careers

Open positions

We're hiring

Help build the next chapter of the web

CDN

DNS

Streaming

Fast Edge

Image Optimization

AI Inference

GPU Cloud

AI Cloud