FastEdge
Run application
logic where
requests happen
Store assets, backups, logs, and app data in S3-compatible storage that gives content a cleaner route to the edge. Keep familiar tools, control access, and remove extra origin work between storage and delivery.
No credit card needed
Start in 2minutes
Generous FREE tier
Build, ship, and respond from the edge
Deploy edge logic without provisioning servers, managing regions, or rebuilding your backend for every new request-time decision.
01
Start with code or a template
Write request-time logic in JavaScript or Rust, or
use a FastEdge template for routing, access, personalization, and more.
02
Deploy it across the edge
Push your FastEdge application through the Portal, API, CLI, or Terraform, then
run it closer to users on Gcore’s edge network.
03
Serve the right response
Run decisions at the edge, use nearby data for fast reads, and send traffic back to origin only when it is needed.
Built for edge logic. Without the server work.
Move routing, access, personalization, and transformation logic closer to users while keeping server setup and runtime operations out of your way.
Build in familiar ways
Create FastEdge apps with documented JavaScript and Rust SDK paths, then deploy them as WebAssembly applications at the edge.
Deploy without provisioning
Push apps through the Customer Portal, API, CLI, or Terraform and bring edge logic online without managing servers, regions, or infrastructure.
Run in an isolated sandbox
Keep edge applications isolated inside a WebAssembly sandbox designed for controlled request execution.
Scale with real traffic
Handle changing demand without pre-provisioning capacity or paying for idle infrastructure your application is not using.
Connect what logic needs
Use Secrets Manager for sensitive values and Edge Storage for fast reads from rules, flags, entitlements, or policy data.
Keep data where
decisions happen
Add Edge Storage when your edge logic
needs fast reads from rules, flags, entitlements, allowlists, blocklists, or policy data.
Keep the right data close to the request, and
send traffic back to origin only when needed.
Built for read-heavy edge data
Global write replication, typically within seconds
Good fit for flags, rules, entitlements, and allowlists
CDN delivers. FastEdge handles the logic.
Fast delivery is only the start. Access checks, routing, personalization, and response changes still go back
to origin unless they run at the edge. FastEdge puts that logic closer to your users.
Change content, language, currency, experiments, or feature flags based on request context and nearby data.
Validate tokens, signed parameters, IPs, keys, and entitlement data before protected content is served.
Apply geo rules, release windows, failover logic, or smart-origin selection closer to the user.
Modify headers, rewrite URLs, transform content, or shape frontend responses before they reach the user.
Serve frontend responses, small APIs, generated files, or dynamic content directly from the edge.
Move repeat checks, lightweight API logic, and high-frequency policy reads to the edge so origin handles only what it needs to.
More of your edge stack. Less patchwork.
Bring delivery, compute, data, and security closer together on Gcore's edge platform.
Keep your request path growing without turning every new layer into another vendor project.
Edge Points of Presence
Delivering content closer to users around the world.
Edge Points of Presence
Delivering content closer to users around the world.
EDGE COMPUTE COLD START
Run WebAssembly logic at the edge without noticeable startup delay.
GLOBAL DATA REPLICATION
Distribute flags, rules, and entitlements across the edge.
See the logic in action
Five FastEdge functions running on real Gcore edge servers. Pick a demo to see what it does and how it's written.
Rewrite HTML at the edge before it reaches the browser
Modify any HTML element — headings, links, attributes, or inner content — directly in the response stream, without touching your origin server.
// FastEdge — HTML Rewriter
import { HTMLRewriter } from "fastedge:html";
export default async function handler(req: Request) {
const res = await fetch(req);
return new HTMLRewriter()
.on("h1", {
element(el) {
el.setInnerContent("Hello from the edge");
}
})
.transform(res);
}Accept uploads at the edge and forward to object storage
Handle file uploads at the closest PoP and stream them to storage without sending the upload through your backend.
// FastEdge — S3 Uploader
import { S3Client } from "fastedge:s3";
export default async function handler(req: Request) {
const key = new URL(req.url).pathname.slice(1);
const body = await req.arrayBuffer();
const s3 = new S3Client({
bucket: "my-edge-bucket",
region: "us-east-1",
});
await s3.put(key, body);
return new Response("uploaded", { status: 201 });
}Build custom DNS-over-HTTP logic at the edge
Resolve queries, apply overrides, or route by region from a single edge function.
// FastEdge — DNS Resolver
import { dns } from "fastedge:dns";
export default async function handler(req: Request) {
const url = new URL(req.url);
const host = url.searchParams.get("host") ?? "";
const records = await dns.resolve(host, "A");
return Response.json({ host, records, ttl: 300 });
}Generate PDF documents on demand, without a server
Render PDFs from a template and request data directly at the edge. No backend, no lambda, no queue — just a function that returns a file.
// FastEdge — PDF Generator
import { pdf } from "fastedge:pdf";
import { template } from "./invoice.template";
export default async function handler(req: Request) {
const data = await req.json();
const doc = await pdf.render(template, data);
return new Response(doc, {
headers: {
"content-type": "application/pdf",
"content-disposition": 'attachment; filename="invoice.pdf"',
},
});
}Free to build. Usage-based to scale.
Start with a free edge app, then scale based on the compute and edge data your application actually uses.
FastEdge calls every month
100 ms runtime duration per call
50 MB memory per call
10M Edge Storage read requests
1M Edge Storage delete requests
720 MB·hours included storage
plus usage-based overages
3M FastEdge calls included
5s runtime duration per call
200 MB memory per call
10M Edge Storage read requests
10 MB included write size
Usage-based pricing beyond included limits
Need custom limits or migration support?
Plan high-volume workloads, custom usage, and advanced architecture needs.
Built for real traffic.
Ready for edge logic.
Because traffic still has to reach the right place even when demand spikes.
"We needed a CDN provider that could deliver enterprise-grade performance at global scale. The right partner needed proven infrastructure across all major regions and the technical capability to integrate seamlessly with our existing architecture."
Start building where requests happen
Set up DNS that resolves faster, routes smarter, and stays ready as your traffic grows.
No credit card needed · Start in 2 minutes
What to now before you build
Edge compute works best when every layer has a clear job.




