1
Choose a route
Create the path your application expects, such as /users, /products or /orders.
Fake API Generator
Generate a Fake API with Your Own JSON
Turn your JSON into a hosted API endpoint your application can call. Build frontend features, prototypes and demos without creating temporary backend code.
Hosted HTTPS endpoints. No temporary backend server required.
JSON to API
Turn sample JSON into a working endpoint
Start with the data structure your interface needs. Instead of importing that data directly into your frontend, return it from a hosted endpoint and exercise the same request flow you will use with the production backend.
Your generated endpoint
GET
/usershttps://apis.getforgeapi.com/YOUR_PROJECT_KEY/users
users.jsonjson
[
{
"id": 1,
"name": "Alex Morgan",
"email": "alex@example.com",
"role": "Designer",
"active": true
},
{
"id": 2,
"name": "Sam Rivera",
"email": "sam@example.com",
"role": "Developer",
"active": true
}
]How it works
From JSON to a fake API in three steps
2
Add your JSON
Define realistic sample data using the same fields and structure planned for your application.
3
Call the hosted URL
Use the generated HTTPS endpoint from your frontend, prototype, mobile app or test.
Two ways to get started
Use your own JSON or deploy a ready-made API
Build exactly what your application needs from scratch, or start faster with a pre-built Forge API starter project and customize its endpoints and JSON responses.
{}
Generate an API with your own JSON
Create your own route and paste the exact JSON structure your application expects. You control the fields, values and response shape from the beginning.
✓
Choose your own endpoint routes
✓
Use custom objects, arrays and nested JSON
✓
Match your planned production API structure
⚡
Start with a pre-built API project
Need working endpoints immediately? Deploy one of Forge API's ready-made starter projects, then change the routes and JSON responses to match your application.
✓
Deploy multiple useful endpoints at once
✓
Start with realistic sample JSON
✓
Customize the generated project after deployment
Want the fastest starting point?
Use a starter project when you need realistic API endpoints quickly. Once deployed, you can edit the JSON responses and adapt the project to the screens and data structures your frontend requires.
Use it like a real API
Make a real HTTP request from your frontend
Your generated endpoint is available through HTTPS, so you can call it with fetch, Axios or another HTTP client instead of hard-coding the response inside your application.
Frontend examplets
const API_BASE_URL =
"https://apis.getforgeapi.com/YOUR_PROJECT_KEY";
const response = await fetch(`${API_BASE_URL}/users`);
if (!response.ok) {
throw new Error(`Request failed: ${response.status}`);
}
const users = await response.json();
console.log(users);Terminalbash
curl https://apis.getforgeapi.com/YOUR_PROJECT_KEY/usersWhy use an endpoint instead of a local JSON file?
A hosted fake API exercises your application's request, loading, parsing and error-handling code. That makes the development flow closer to the eventual backend integration.
Custom JSON
Create fake API data that matches your interface
Use field names, values, objects, arrays and nested structures that resemble the response your production API will eventually return.
Product data
Populate product cards, detail pages and ecommerce prototypes with predictable sample data.
GET /products/42json
{
"id": 42,
"name": "Wireless Headphones",
"price": 79.99,
"category": "audio",
"inStock": true,
"rating": 4.7
}Dashboard data
Build charts, statistics and dashboard layouts before analytics services or database queries are ready.
GET /dashboardjson
{
"revenue": 48250,
"orders": 318,
"customers": 1240,
"conversionRate": 3.8
}Development workflows
What can you use a fake API for?
Frontend development
Build components and screens against realistic network responses while backend development continues.
Product prototypes
Turn static prototypes into interactive applications that load realistic data over HTTP.
Product demos
Demonstrate application flows without depending on production databases or services.
UI testing
Use controlled data to repeatedly test how interfaces render expected API responses.
Hackathons
Create working API integrations quickly when there is not enough time to build a complete backend.
Mobile development
Use hosted HTTPS endpoints from simulators, emulators and physical devices without relying on localhost.
Fake API vs mock API
Is a fake API different from a mock API?
Developers often use the terms interchangeably. In both cases, the goal is to provide predictable API responses without depending on the final production backend.
Forge API focuses on hosted endpoints that your application can call over HTTP. You control the route and response while your frontend continues using a normal API integration.
Use a fake API when you need to:
✓
Build before the production backend exists
✓
Use realistic sample JSON over HTTP
✓
Create predictable demos and prototypes
✓
Avoid exposing production services during development
✓
Share the same test endpoint across devices
Temporary backend, reusable frontend
Replace the fake API when your backend is ready
Keep your API base URL separate from the components that consume your data. During development it can point to Forge API:
Developmentts
const API_BASE_URL =
"https://apis.getforgeapi.com/YOUR_PROJECT_KEY";When the production backend is available, replace that value:
Productionts
const API_BASE_URL =
"https://api.example.com";Keep the API contract consistent
If your production backend uses the same routes and response structures, your UI code can continue consuming the same data contract after the base URL changes.
Framework tutorials
Connect your frontend to a fake API
Follow a framework-specific tutorial for connecting your application to hosted API endpoints.
React
Load hosted API data from React components.
Read tutorial →Next.js
Use configurable API URLs in a Next.js application.
Read tutorial →React Native
Use hosted endpoints from mobile devices and emulators.
Read tutorial →Vue
Connect a Vue application to hosted test data.
Read tutorial →Angular
Call hosted API endpoints using Angular HttpClient.
Read tutorial →Frequently asked questions
Fake API generator questions
What is a fake API?
A fake API is an API endpoint used during development or testing that returns controlled data instead of depending on a production backend. It lets applications make real HTTP requests while the final backend is unavailable or incomplete.
How do I generate a fake API from JSON?
Create an endpoint, choose its route and HTTP method, add the JSON response you want it to return and use the generated Forge API URL from your application.
Is a fake API the same as a mock API?
The terms are often used for the same development technique. Both describe API endpoints that imitate expected backend responses so applications can be built and tested independently.
Can I use my own JSON data?
Yes. You can define the JSON structure and values returned by your endpoint, including objects, arrays and nested data.
Can I use a fake API for frontend testing?
Yes. A hosted fake API is useful for testing request handling, rendering data and different interface states without calling production services.
Can I use fake API endpoints from mobile apps?
Yes. Forge API endpoints are hosted HTTPS URLs, so they can be called from web applications, mobile applications and other HTTP clients.
Should I put real customer data in a fake API?
No. Use fictional or non-sensitive sample data for development, prototypes, demonstrations and testing.
Generate your fake API and keep building
Create a hosted endpoint with your own JSON response and connect it to your application without building a temporary backend.