Documentation


# Introduction

fakeJSON was designed to get you up and running with fake mock data in no time. Documentation section is where you'll find specific information on understanding and using fakeJSON API.

Endpoint

fakeJSON API endpoint is app.fakejson.com/q with both http and https protocols supported. You can choose to send your request to either http://app.fakejson.com/q or https://app.fakejson.com/q depending on your use case. The API will return a response in JSON format.

HTTP methods

You can make a request using any of the standard methods like: POST, PUT, DELETE, and PATCH. We also support GET method but only through our saved resource feature.

CORS

Our endpoint supports cross-origin resource sharing (CORS). Make XMLHttp requests from anywhere!

Fake Units

Pricing is based on Fake Unit usage. Now you may be thinking, what is a Fake Unit? A Fake Unit is simply how we measure the computational effort required to produce the data for a fake field.

You are allocated a certain daily quota of Fake Units depending on your selected plan. Your Fake Unit quota resets at the end of each day. If you feel that you are consistently using up your daily quota of Fake Units, it's probably a good idea to upgrade your plan to one that better fits your needs. As a rule of thumb, it takes 1 Fake Unit to populate 1 data field. Custom and more complex data fields will consume more Fake Units.

# Request Structure

Every request to fakeJSON endpoint has to follow the same payload format. This format includes your unique token, parameters field (optional) and data field:

                                
{
  "token": "YOUR-SECRET-TOKEN",
  "parameters": {
    "code": 200
  },
  "data": {
    "user_name": "nameFirst",
    "user_email": "internetEmail"
  }
}
                                
                            

# Token

Used to uniquely identify you as a user of fakeJSON. Without token request will be ignored. You can obtain token in the member interface: token page. Tokens never expire, however you can refresh token on the same page.

You can create multiple tokens to share with your team members, designers, developers and so on. Every token comes with a "limit" setting, which limits maximum amount of daily Fake Units, that can be used by the token. Tokens allocated only certain amount of Fake Units per day will not deplete your daily Fake Units allowance completely.

# Parameters

The parameters field allows you to modify response depending on your needs. You can delay response by seconds, or change response code to 404 to test how your application handles "Not Found" responses. Or you can add additional custom headers to the response.

Parameter Description Values
code Response code number you would like to fake. String "404" or integer 404 are both fine. Redirect response codes are not supported.

Only response codes from the list are supported

200, 201, 202, 203, 204, 205, 206, 207, 208, 226, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 421, 422, 423, 424, 426, 428, 429, 431, 451, 500, 501, 502, 503, 504, 505, 506, 507, 508, 510, 511
delay If you wish to test how your app handles delayed responses, or simply enjoy looking at spinning loaders (☞゚ヮ゚)☞ , enter number of seconds you want your response to be delayed by. Integer value from 0 to 10
headers Adding additional headers to response is easy. You can provide a list of key value pairs to include as headers in response. "headers": [{"custom-header": "header value"}, {"custom-header2": "header value 2"}]
consistent Every response is cached by default. This means that each response will return the same consistent dataset unless a modification is made to the request itself. To change this default behaviour, you can add the consistent parameter with a value of false to your request, which will disable caching.

Only value false will be accepted

"consistent": false

# Data

The data field is where most of the action happens. It defines the format of the response to be returned and the subsequent response dataset. It consists of fields, objects and arrays like any other valid JSON. It follows a key value pair format. You can name the data key however you like but the value field has to follow the exact syntax of fakeJSON field you wish to use. You may nest objects within the data field to match exactly the kind of response you need. There is also a specific parameter called _repeat which you can add to your data field. This parameter lets the API know how many iterations of an object to return.

Here is an example of a simple request:

Request with _repeat parameter

                                        
{
  "token": "YOUR-SECRET-TOKEN",
  "data": {
    "user_name": "nameFirst",
    "user_email": "internetEmail",
    "_repeat": 3
  }
}
                                        
                                    

Response

                                        
[
  {
    "user_name": "Axel",
    "user_email": "gage@gmail.com"
  },
  {
    "user_name": "Yazmin",
    "user_email": "colten@outlook.com"
  },
  {
    "user_name": "Giles",
    "user_email": "amya@hotmail.com"
  }
]
                                        
                                    

Nested request

                                        
{
  "token": "YOUR-SECRET-TOKEN",
  "data": {
    "first_name": "nameFirst",
    "last_name": "nameLast",
    "location": {
      "street": "addressStreetName",
      "city": "addressCity",
      "state": "addressState",
      "country": "addressCountry"
      },
    "contacts": {
      "email": "internetEmail",
      "mobile": "phoneMobile"
      },
    "job": {
      "company": "companyName",
      "department": "companyDepartment",
      "position": "personTitle",
      "phone_numbers": "functionArray|3|phoneHome"
      }
  }
}
                                        
                                    

Response

                                        
{
  "first_name": "Eugenia",
  "last_name": "Williamson",
  "location": {
    "street": "Water Street",
    "state": "Oklahoma",
    "country": "Mauritius",
    "city": "Le Grand"
  },
  "contacts": {
    "mobile": "1-631-908-9996",
    "email": "alva@yahoo.com"
  },
  "job": {
    "company": "Unaplex",
    "department": "sales",
    "position": "Central Applications Officer",
    "phone_numbers": [
      "1-959-166-4973 x3211",
      "206.978.0656 x923",
      "283-282-4811"
    ]
  }
}
                                        
                                    

# Fields


The building blocks that make up your API data request.

Building mock data for your development needs should be easy. With fakeJSON, it really is. Define your data schema according to your requirements with a simple JSON request containing your request fields. Need something different? Simply insert a different field type to match your needs.

fakeJSON has numerous field types for you to readily populate your data with. Some of these fields are a little more complex than others as they require further customizations to them. Examples of these customizable fields are those involving lengths and ranges. All customizable fields follow a consistent format:

sectionField|customization1|customization2. For example: numberFloat|10,20|3. This field example indicates that this particular data response needs to be populated with a number which is a float in the range of 10 to 20 with only 3 decimals after the dot. Not all fields are customizable. Please review the field documentations below to explore more.

If you entered an invalid field which does not match any of fakeJSON's field types, the response for that field will be returned as you entered it.

# Name
Plans All
FakeUnits 1FK
Field Description
nameFirst First Names
nameLast Last Names
nameMiddle Middle Names
name First Name + Last Name
namePrefix Name preffixes
nameSuffix Name suffixes
                                                    
curl --request POST \
  --url https://app.fakejson.com/q \
  --header 'content-type: application/json' \
  --data '{
    "token": "YOUR-SECRET-TOKEN",
    "data": {
      "nameFirst": "nameFirst",
      "nameLast": "nameLast",
      "nameMiddle": "nameMiddle",
      "name": "name",
      "namePrefix": "namePrefix",
      "nameSuffix": "nameSuffix"
      }
    }'
                                                    
                                                
                                                    
var body = {
  token: "YOUR-SECRET-TOKEN",
  data: {
    nameFirst: "nameFirst",
    nameLast: "nameLast",
    nameMiddle: "nameMiddle",
    name: "name",
    namePrefix: "namePrefix",
    nameSuffix: "nameSuffix"
    }};

$.ajax({
  method: "POST",
  url: "https://app.fakejson.com/q",
  data: body
  }).done(function(msg) {
    console.log(msg);
});
                                                    
                                                
                                                    
require 'uri'
require 'net/http'
require 'openssl'
require 'json'

url = URI("https://app.fakejson.com/q")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
http.verify_mode = OpenSSL::SSL::VERIFY_NONE

request = Net::HTTP::Post.new(url)
request.body = {
  token: 'YOUR-SECRET-TOKEN',
  data: {
    nameFirst: 'nameFirst',
    nameLast: 'nameLast',
    nameMiddle: 'nameMiddle',
    name: 'name',
    namePrefix: 'namePrefix',
    nameSuffix: 'nameSuffix'
  }}.to_json

response = http.request(request)
puts response.read_body
                                                    
                                                
                                                    
var request = require('request');

var body = {
  token: 'YOUR-SECRET-TOKEN',
  data: {
    nameFirst: 'nameFirst',
    nameLast: 'nameLast',
    nameMiddle: 'nameMiddle',
    name: 'name',
    namePrefix: 'namePrefix',
    nameSuffix: 'nameSuffix'
}};

request.post(
  'https://app.fakejson.com/q',
  {json: body},
  function (error, response, body) {
    if (!error && response.statusCode == 200) {
      console.log(body)
    }
  }
);
                                                    
                                                
                                                    
import requests

body = {
  'token': 'YOUR-SECRET-TOKEN',
  'data': {
    'nameFirst': 'nameFirst',
    'nameLast': 'nameLast',
    'nameMiddle': 'nameMiddle',
    'name': 'name',
    'namePrefix': 'namePrefix',
    'nameSuffix': 'nameSuffix'
}}

r = requests.post('https://app.fakejson.com/q', json = body)

                                                    
                                                
                                                    
package main

import (
  "fmt"
  "strings"
  "net/http"
  "io/ioutil"
  )

func main() {

url := "https://app.fakejson.com/q"

payload := strings.NewReader("{\"token\":\"YOUR-TOKEN\",
\"data\":{\"nameFirst\":\"nameFirst\",
\"nameLast\":\"nameLast\",
\"nameMiddle\":\"nameMiddle\",
\"name\":\"name\",
\"namePrefix\":\"namePrefix\",
\"nameSuffix\":\"nameSuffix\"}}")

req, _ := http.NewRequest("POST", url, payload)

res, _ := http.DefaultClient.Do(req)

defer res.Body.Close()
body, _ := ioutil.ReadAll(res.Body)

fmt.Println(res)
  fmt.Println(string(body))
}
                                                    
                                                
# Address
Plans All
FakeUnits 1FK
Field Description
addressBuilding Building Addresses
addressStreetName Street Names
addressStreetSuffix Street Suffix
addressCity Cities
addressState State
addressStateCode State Code
addressCountry Countries
addressZipCode Zip Code
addressFullStreet Full Street name with number
addressLongitude Longitude
addressLatitude Latitude
addressCoordinates Latitude, Longitude
                                                    
curl --request POST \
  --url https://app.fakejson.com/q \
  --header 'content-type: application/json' \
  --data '{
    "token": "YOUR-SECRET-TOKEN",
    "data": {
      "addressBuilding": "addressBuilding",
      "addressStreetName": "addressStreetName",
      "addressStreetSuffix": "addressStreetSuffix",
      "addressCity": "addressCity",
      "addressState": "addressState",
      "addressStateCode": "addressStateCode",
      "addressCountry": "addressCountry",
      "addressZipCode": "addressZipCode",
      "addressFullStreet": "addressFullStreet",
      "addressLongitude": "addressLongitude",
      "addressLatitude": "addressLatitude"
      }
    }'
                                                    
                                                
                                                    
var body = {
  token: "YOUR-SECRET-TOKEN",
  data: {
    addressBuilding: "addressBuilding",
    addressStreetName: "addressStreetName",
    addressStreetSuffix: "addressStreetSuffix",
    addressCity: "addressCity",
    addressState: "addressState",
    addressStateCode: "addressStateCode",
    addressCountry: "addressCountry",
    addressZipCode: "addressZipCode",
    addressFullStreet: "addressFullStreet",
    addressLongitude: "addressLongitude",
    addressLatitude: "addressLatitude"
    }};

$.ajax({
  method: "POST",
  url: "https://app.fakejson.com/q",
  data: body
  }).done(function(msg) {
    console.log(msg);
});
                                                    
                                                
                                                    
require 'uri'
require 'net/http'
require 'openssl'
require 'json'

url = URI("https://app.fakejson.com/q")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
http.verify_mode = OpenSSL::SSL::VERIFY_NONE

request = Net::HTTP::Post.new(url)
request.body = {
  token: 'YOUR-SECRET-TOKEN',
  data: {
    addressBuilding: 'addressBuilding',
    addressStreetName: 'addressStreetName',
    addressStreetSuffix: 'addressStreetSuffix',
    addressCity: 'addressCity',
    addressState: 'addressState',
    addressStateCode: 'addressStateCode',
    addressCountry: 'addressCountry',
    addressZipCode: 'addressZipCode',
    addressFullStreet: 'addressFullStreet',
    addressLongitude: 'addressLongitude',
    addressLatitude: 'addressLatitude'
  }}.to_json

response = http.request(request)
puts response.read_body
                                                    
                                                
                                                    
var request = require('request');

var body = {
  token: 'YOUR-SECRET-TOKEN',
  data: {
    addressBuilding: 'addressBuilding',
    addressStreetName: 'addressStreetName',
    addressStreetSuffix: 'addressStreetSuffix',
    addressCity: 'addressCity',
    addressState: 'addressState',
    addressStateCode: 'addressStateCode',
    addressCountry: 'addressCountry',
    addressZipCode: 'addressZipCode',
    addressFullStreet: 'addressFullStreet',
    addressLongitude: 'addressLongitude',
    addressLatitude: 'addressLatitude'
}};

request.post(
  'https://app.fakejson.com/q',
  {json: body},
  function (error, response, body) {
    if (!error && response.statusCode == 200) {
      console.log(body)
    }
  }
);
                                                    
                                                
                                                    
import requests

body = {
  'token': 'YOUR-SECRET-TOKEN',
  'data': {
    'addressBuilding': 'addressBuilding',
    'addressStreetName': 'addressStreetName',
    'addressStreetSuffix': 'addressStreetSuffix',
    'addressCity': 'addressCity',
    'addressState': 'addressState',
    'addressStateCode': 'addressStateCode',
    'addressCountry': 'addressCountry',
    'addressZipCode': 'addressZipCode',
    'addressFullStreet': 'addressFullStreet',
    'addressLongitude': 'addressLongitude',
    'addressLatitude': 'addressLatitude'
}}

r = requests.post('https://app.fakejson.com/q', json = body)

                                                    
                                                
                                                    
package main

import (
  "fmt"
  "strings"
  "net/http"
  "io/ioutil"
  )

func main() {

url := "https://app.fakejson.com/q"


payload := strings.NewReader("{\"token\":\"YOUR-TOKEN\",
\"data\":{\"addressBuilding\":\"addressBuilding\",
\"addressStreetName\":\"addressStreetName\",
\"addressStreetSuffix\":\"addressStreetSuffix\",
\"addressCity\":\"addressCity\",
\"addressState\":\"addressState\",
\"addressStateCode\":\"addressStateCode\",
\"addressCountry\":\"addressCountry\",
\"addressZipCode\":\"addressZipCode\",
\"addressFullStreet\":\"addressFullStreet\",
\"addressLongitude\":\"addressLongitude\",
\"addressLatitude\":\"addressLatitude\"}}")

req, _ := http.NewRequest("POST", url, payload)

res, _ := http.DefaultClient.Do(req)

defer res.Body.Close()
body, _ := ioutil.ReadAll(res.Body)

fmt.Println(res)
  fmt.Println(string(body))
}
                                                    
                                                
# Phone
Plans All
FakeUnits 1FK
Field Description
phoneMobile Mobile format number
phoneHome Home format number
                                                    
curl --request POST \
  --url https://app.fakejson.com/q \
  --header 'content-type: application/json' \
  --data '{
    "token": "YOUR-SECRET-TOKEN",
    "data": {
      "phoneMobile": "phoneMobile",
      "phoneHome": "phoneHome"
      }
    }'
                                                    
                                                
                                                    
var body = {
  token: "YOUR-SECRET-TOKEN",
  data: {
    phoneMobile: "phoneMobile",
    phoneHome: "phoneHome"
    }};

$.ajax({
  method: "POST",
  url: "https://app.fakejson.com/q",
  data: body
  }).done(function(msg) {
    console.log(msg);
});
                                                    
                                                
                                                    
require 'uri'
require 'net/http'
require 'openssl'
require 'json'

url = URI("https://app.fakejson.com/q")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
http.verify_mode = OpenSSL::SSL::VERIFY_NONE

request = Net::HTTP::Post.new(url)
request.body = {
  token: 'YOUR-SECRET-TOKEN',
  data: {
    phoneMobile: 'phoneMobile',
    phoneHome: 'phoneHome'
  }}.to_json

response = http.request(request)
puts response.read_body
                                                    
                                                
                                                    
var request = require('request');

var body = {
  token: 'YOUR-SECRET-TOKEN',
  data: {
    phoneMobile: 'phoneMobile',
    phoneHome: 'phoneHome'
}};

request.post(
  'https://app.fakejson.com/q',
  {json: body},
  function (error, response, body) {
    if (!error && response.statusCode == 200) {
      console.log(body)
    }
  }
);
                                                    
                                                
                                                    
import requests

body = {
  'token': 'YOUR-SECRET-TOKEN',
  'data': {
    'phoneMobile': 'phoneMobile',
    'phoneHome': 'phoneHome'
}}

r = requests.post('https://app.fakejson.com/q', json = body)

                                                    
                                                
                                                    
package main

import (
  "fmt"
  "strings"
  "net/http"
  "io/ioutil"
  )

func main() {

url := "https://app.fakejson.com/q"

payload := strings.NewReader("{\"token\":\"YOUR-TOKEN\",
\"data\":{\"phoneMobile\":\"phoneMobile\",
\"phoneHome\":\"phoneHome\"}}")

req, _ := http.NewRequest("POST", url, payload)

res, _ := http.DefaultClient.Do(req)

defer res.Body.Close()
body, _ := ioutil.ReadAll(res.Body)

fmt.Println(res)
  fmt.Println(string(body))
}
                                                    
                                                
# Number
Plans All
FakeUnits 1FK
Field Description
numberInt Random Integer
numberInt|x,y Random Integer Range
numberFloat Random Float
numberFloat|x,y|z Random Float in range, rounded to z decimals
numberBool Random Boolean
                                                    

curl --request POST \
  --url https://app.fakejson.com/q \
  --header 'content-type: application/json' \
  --data '{
    "token": "YOUR-SECRET-TOKEN",
    "data": {
      "numberInt": "numberInt",
      "numberFloat": "numberFloat",
      "numberBool": "numberBool"
      }
    }'
                                                    
                                                
                                                    
var body = {
  token: "YOUR-SECRET-TOKEN",
  data: {
    numberInt: "numberInt",
    numberFloat: "numberFloat",
    numberBool: "numberBool"
    }};

$.ajax({
  method: "POST",
  url: "https://app.fakejson.com/q",
  data: body
  }).done(function(msg) {
    console.log(msg);
});
                                                    
                                                
                                                    
require 'uri'
require 'net/http'
require 'openssl'
require 'json'

url = URI("https://app.fakejson.com/q")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
http.verify_mode = OpenSSL::SSL::VERIFY_NONE

request = Net::HTTP::Post.new(url)
request.body = {
  token: 'YOUR-SECRET-TOKEN',
  data: {
    numberInt: 'numberInt',
    numberFloat: 'numberFloat',
    numberBool: 'numberBool'
  }}.to_json

response = http.request(request)
puts response.read_body
                                                    
                                                
                                                    
var request = require('request');

var body = {
  token: 'YOUR-SECRET-TOKEN',
  data: {
    numberInt: 'numberInt',
    numberFloat: 'numberFloat',
    numberBool: 'numberBool'
}};

request.post(
  'https://app.fakejson.com/q',
  {json: body},
  function (error, response, body) {
    if (!error && response.statusCode == 200) {
      console.log(body)
    }
  }
);
                                                    
                                                
                                                    
import requests

body = {
  'token': 'YOUR-SECRET-TOKEN',
  'data': {
    'numberInt': 'numberInt',
    'numberFloat': 'numberFloat',
    'numberBool': 'numberBool'
}}

r = requests.post('https://app.fakejson.com/q', json = body)

                                                    
                                                
                                                    
package main

import (
  "fmt"
  "strings"
  "net/http"
  "io/ioutil"
  )

func main() {

url := "https://app.fakejson.com/q"

payload := strings.NewReader("{\"token\":\"YOUR-SECRET-TOKEN\",
\"data\":{\"numberInt\":\"numberInt\",
\"numberFloat\":\"numberFloat\",
\"numberBool\":\"numberBool\"}}")

req, _ := http.NewRequest("POST", url, payload)

res, _ := http.DefaultClient.Do(req)

defer res.Body.Close()
body, _ := ioutil.ReadAll(res.Body)

fmt.Println(res)
  fmt.Println(string(body))
}
                                                    
                                                
# Date and Time
Plans All
FakeUnits 1FK
Field Description
date Random Date
date|format Random Date in format
dateToday Today's Date
dateToday|format Today's Date in format
dateTime Random Date Time
dateTime|format Random Date Time in format
dateNow Current Time and Date
dateNow|format Current Time and Date in format
dateDOB Random Date of Birth. In the range from today, going back 85 years.
dateDOB|format Random Date of Birth. In the range from today, going back 85 years in format
dateUnix Current Unix timestamp
time Random time
timeNow Current time in UTC
                                                    
curl --request POST \
  --url https://app.fakejson.com/q \
  --header 'content-type: application/json' \
  --data '{
    "token": "YOUR-SECRET-TOKEN",
    "data": {
      "date": "date",
      "dateToday": "dateToday",
      "dateTime": "dateTime",
      "dateNow": "dateNow",
      "dateUnix": "dateUnix",
      "timeNow": "timeNow",
      "timeUnix": "timeUnix"
      }
    }'
                                                    
                                                
                                                    
var body = {
  token: "YOUR-SECRET-TOKEN",
  data: {
    date: "date",
    dateToday: "dateToday",
    dateTime: "dateTime",
    dateNow: "dateNow",
    dateUnix: "dateUnix"
    timeNow: "timeNow",
    time: "time"
    }};

$.ajax({
  method: "POST",
  url: "https://app.fakejson.com/q",
  data: body
  }).done(function(msg) {
    console.log(msg);
});
                                                    
                                                
                                                    
require 'uri'
require 'net/http'
require 'openssl'
require 'json'

url = URI("https://app.fakejson.com/q")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
http.verify_mode = OpenSSL::SSL::VERIFY_NONE

request = Net::HTTP::Post.new(url)
request.body = {
  token: 'YOUR-SECRET-TOKEN',
  data: {
    date: 'date',
    dateToday: 'dateToday',
    dateTime: 'dateTime',
    dateNow: 'dateNow',
    dateUnix: 'dateUnix',
    timeNow: 'timeNow',
    time: 'time'
  }}.to_json

response = http.request(request)
puts response.read_body
                                                    
                                                
                                                    
var request = require('request');

var body = {
  token: 'YOUR-SECRET-TOKEN',
  data: {
    date: 'date',
    dateToday: 'dateToday',
    dateTime: 'dateTime',
    dateNow: 'dateNow',
    dateUnix: 'dateUnix',
    timeNow: 'timeNow',
    time: 'time'
}};

request.post(
  'https://app.fakejson.com/q',
  {json: body},
  function (error, response, body) {
    if (!error && response.statusCode == 200) {
      console.log(body)
    }
  }
);
                                                    
                                                
                                                    
import requests

body = {
  'token': 'YOUR-SECRET-TOKEN',
  'data': {
    'date': 'date',
    'dateToday': 'dateToday',
    'dateTime': 'dateTime',
    'dateNow': 'dateNow',
    'dateUnix': 'dateUnix',
    'timeNow': 'timeNow',
    'time': 'time'
}}

r = requests.post('https://app.fakejson.com/q', json = body)

                                                    
                                                
                                                    
package main

import (
  "fmt"
  "strings"
  "net/http"
  "io/ioutil"
  )

func main() {

url := "https://app.fakejson.com/q"

payload := strings.NewReader("{\"token\":\"YOUR-SECRET-TOKEN\",
\"data\":{\"date\":\"date\",
\"dateToday\":\"dateToday\",
\"dateTime\":\"dateTime\",
\"timeNow\": \"timeNow\",
\"time\": \"time\",
\"dateNow\":\"dateNow\",
\"dateUnix\":\"dateUnix\"}}")

req, _ := http.NewRequest("POST", url, payload)

res, _ := http.DefaultClient.Do(req)

defer res.Body.Close()
body, _ := ioutil.ReadAll(res.Body)

fmt.Println(res)
  fmt.Println(string(body))
}
                                                    
                                                

Date fields support format option, which allows you to return this field in format required by your application.

Format Description Result
ISO:Basic <date>T<time><offset> 19840720T140406+0000
ISO:Basic:Z <date>T<time><offset>Z 20040904T191712Z
ISO:Extended <date>T<time><offset> 1939-05-28T10:19:42+00:00
ISO:Extended:Z <date>T<time><offset>Z 1953-06-10T09:49:47Z
ISOdate YYYY-MM-DD 1953-06-10
ISOtime hh:mm:ss 08:45:33
ISOweek YYYY-Www 1950-W03
ISOweek YYYY-Www 1950-W03
RFC822 Thu, 17 May 56 15:53:57 +0000
RFC822z Fri, 27 Jan 67 00:13:40 Z
RFC1123 Mon, 23 Jul 1984 13:15:48 +0000
RFC1123z Sat, 13 Jan 2001 13:02:37 Z
RFC3339 2004-09-07T22:28:55+00:00
RFC3339z 1980-03-05T07:53:26Z
ANSIC Mon Apr 14 04:54:10 1997
UNIX Wed Jul 2 04:50:28 UTC 2008
ASN1:UTCtime 141012192812Z

Any other format will not be matched

# String
Plans All
FakeUnits 1FK
Field Description
stringShort Random sentence
stringShort|x,y Random x to y sentences
stringLong Random paragraph
stringCharacters Random 5 characters
stringCharacters|x,y Random x to y characters
stringDigits Random 5 digits
stringDigits|x,y Random x to y digits
stringAlphaNum Random 5 alpha numeric characters
stringAlphaNum|x,y Random x to y alpha numeric characters
stringWords Random 3 words
stringWords|x,y Random x to y words
                                                    
curl --request POST \
  --url https://app.fakejson.com/q \
  --header 'content-type: application/json' \
  --data '{
    "token": "YOUR-SECRET-TOKEN",
    "data": {
      "stringShort": "stringShort",
      "stringLong": "stringLong",
      "stringCharacters": "stringCharacters",
      "stringDigits": "stringDigits",
      "stringAlphaNum": "stringAlphaNum",
      "stringWords": "stringWords"
      }
    }'
                                                    
                                                
                                                    
var body = {
  token: "YOUR-SECRET-TOKEN",
  data: {
    stringShort: "stringShort",
    stringLong: "stringLong",
    stringCharacters: "stringCharacters",
    stringDigits: "stringDigits",
    stringAlphaNum: "stringAlphaNum",
    stringWords: "stringWords"
    }};

$.ajax({
  method: "POST",
  url: "https://app.fakejson.com/q",
  data: body
  }).done(function(msg) {
    console.log(msg);
});
                                                    
                                                
                                                    
require 'uri'
require 'net/http'
require 'openssl'
require 'json'

url = URI("https://app.fakejson.com/q")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
http.verify_mode = OpenSSL::SSL::VERIFY_NONE

request = Net::HTTP::Post.new(url)
request.body = {
  token: 'YOUR-SECRET-TOKEN',
  data: {
    stringShort: 'stringShort',
    stringLong: 'stringLong',
    stringCharacters: 'stringCharacters',
    stringDigits: 'stringDigits',
    stringAlphaNum: 'stringAlphaNum',
    stringWords: 'stringWords'
  }}.to_json

response = http.request(request)
puts response.read_body
                                                    
                                                
                                                    
var request = require('request');

var body = {
  token: 'YOUR-SECRET-TOKEN',
  data: {
    stringShort: 'stringShort',
    stringLong: 'stringLong',
    stringCharacters: 'stringCharacters',
    stringDigits: 'stringDigits',
    stringAlphaNum: 'stringAlphaNum',
    stringWords: 'stringWords'
}};

request.post(
  'https://app.fakejson.com/q',
  {json: body},
  function (error, response, body) {
    if (!error && response.statusCode == 200) {
      console.log(body)
    }
  }
);
                                                    
                                                
                                                    
import requests

body = {
  'token': 'YOUR-SECRET-TOKEN',
  'data': {
    'stringShort': 'stringShort',
    'stringLong': 'stringLong',
    'stringCharacters': 'stringCharacters',
    'stringDigits': 'stringDigits',
    'stringAlphaNum': 'stringAlphaNum',
    'stringWords': 'stringWords'
}}

r = requests.post('https://app.fakejson.com/q', json = body)

                                                    
                                                
                                                    
package main

import (
  "fmt"
  "strings"
  "net/http"
  "io/ioutil"
  )

func main() {

url := "https://app.fakejson.com/q"

payload := strings.NewReader("{\"token\":\"YOUR-SECRET-TOKEN\",
\"data\":{\"stringShort\":\"stringShort\",
g\"stringLong\":\"stringLong\",
\"stringCharacters\":\"stringCharacters\",
\"stringDigits\":\"stringDigits\",
\"stringAlphaNum\":\"stringAlphaNum\",
\"stringWords\":\"stringWords\"}}")

req, _ := http.NewRequest("POST", url, payload)

res, _ := http.DefaultClient.Do(req)

defer res.Body.Close()
body, _ := ioutil.ReadAll(res.Body)

fmt.Println(res)
  fmt.Println(string(body))
}
                                                    
                                                
# Internet
Plans All
FakeUnits 1FK
Field Description
internetEmail Random Email address
internetDomain Random Domain
internetUrl Random URL
internetIP4 Random IP4 address
internetIP6 Random IP6 address
internetUA Random User Agent String
                                                    
curl --request POST \
  --url https://app.fakejson.com/q \
  --header 'content-type: application/json' \
  --data '{
    "token": "YOUR-SECRET-TOKEN",
    "data": {
      "internetEmail": "internetEmail",
      "internetDomain": "internetDomain",
      "internetUrl": "internetUrl",
      "internetIP4": "internetIP4",
      "internetIP6": "internetIP6",
      "internetUA": "internetUA"
      }
    }'
                                                    
                                                
                                                    
var body = {
  token: "YOUR-SECRET-TOKEN",
  data: {
    internetEmail: "internetEmail",
    internetDomain: "internetDomain",
    internetUrl: "internetUrl",
    internetIP4: "internetIP4",
    internetIP6: "internetIP6",
    internetUA: "internetUA"
    }};

$.ajax({
  method: "POST",
  url: "https://app.fakejson.com/q",
  data: body
  }).done(function(msg) {
    console.log(msg);
});
                                                    
                                                
                                                    
require 'uri'
require 'net/http'
require 'openssl'
require 'json'

url = URI("https://app.fakejson.com/q")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
http.verify_mode = OpenSSL::SSL::VERIFY_NONE

request = Net::HTTP::Post.new(url)
request.body = {
  token: 'YOUR-SECRET-TOKEN',
  data: {
    internetEmail: 'internetEmail',
    internetDomain: 'internetDomain',
    internetUrl: 'internetUrl',
    internetIP4: 'internetIP4',
    internetIP6: 'internetIP6',
    internetUA: 'internetUA'
  }}.to_json

response = http.request(request)
puts response.read_body
                                                    
                                                
                                                    
var request = require('request');

var body = {
  token: 'YOUR-SECRET-TOKEN',
  data: {
    internetEmail: 'internetEmail',
    internetDomain: 'internetDomain',
    internetUrl: 'internetUrl',
    internetIP4: 'internetIP4',
    internetIP6: 'internetIP6',
    internetUA: 'internetUA'
}};

request.post(
  'https://app.fakejson.com/q',
  {json: body},
  function (error, response, body) {
    if (!error && response.statusCode == 200) {
      console.log(body)
    }
  }
);
                                                    
                                                
                                                    
import requests

body = {
  'token': 'YOUR-SECRET-TOKEN',
  'data': {
    'internetEmail': 'internetEmail',
    'internetDomain': 'internetDomain',
    'internetUrl': 'internetUrl',
    'internetIP4': 'internetIP4',
    'internetIP6': 'internetIP6',
    'internetUA': 'internetUA'
}}

r = requests.post('https://app.fakejson.com/q', json = body)

                                                    
                                                
                                                    
package main

import (
  "fmt"
  "strings"
  "net/http"
  "io/ioutil"
  )

func main() {

url := "https://app.fakejson.com/q"

payload := strings.NewReader("{\"token\":\"YOUR-SECRET-TOKEN\",
\"data\":{\"internetEmail\":\"internetEmail\",
\"internetDomain\":\"internetDomain\",
\"internetUrl\":\"internetUrl\",
\"internetIP4\":\"internetIP4\",
\"internetIP6\":\"internetIP6\",
\"internetUA\":\"internetUA\"}}")

req, _ := http.NewRequest("POST", url, payload)

res, _ := http.DefaultClient.Do(req)

defer res.Body.Close()
body, _ := ioutil.ReadAll(res.Body)

fmt.Println(res)
  fmt.Println(string(body))
}
                                                    
                                                
# Naughty String
Plans DEVELOPER, SMALL TEAM, BIG TEAM
FakeUnits 1FK

Test your application with strings that wreak havoc. Big thanks to Big List of Naughty Strings!

Field Description
naughtyFalsey Random values that could be considered falsey.
naughtyNumber Ransom strings that could be interpreted as numbers
naughtySpecialChars Random special characters
naughtySymbols Random symbols
naughtyQuotes All random combinations of quotes
naughtyTwoByte Two Byte characters
naughtyJapan Common Japanese emojies
naughtyEmoji UTF emoji symbols
naughtyRTL Right to left text
naughtyTrick Trick strings
naughtyCorrupted Corrupted text
naughtyUpDown Upside down text
naughtyInjection Script injection text
naughtyOneOf Random naughty string
                                                    
curl --request POST \
  --url https://app.fakejson.com/q \
  --header 'content-type: application/json' \
  --data '{
    "token": "YOUR-SECRET-TOKEN",
    "data": {
      "naughtyFalsey": "naughtyFalsey",
      "naughtyNumber": "naughtyNumber",
      "naughtySpecialChars": "naughtySpecialChars",
      "naughtySymbols": "naughtySymbols",
      "naughtyQuotes": "naughtyQuotes",
      "naughtyTwoByte": "naughtyTwoByte",
      "naughtyJapan": "naughtyJapan",
      "naughtyEmoji": "naughtyEmoji",
      "naughtyRTL": "naughtyRTL",
      "naughtyTrick": "naughtyTrick",
      "naughtyCorrupted": "naughtyCorrupted",
      "naughtyUpDown": "naughtyUpDown",
      "naughtyInjection": "naughtyInjection",
      "naughtyOneOf": "naughtyOneOf"
      }
    }'
                                                    
                                                
                                                    
var body = {
  token: "YOUR-SECRET-TOKEN",
  data: {
    naughtyFalsey: "naughtyFalsey",
    naughtyNumber: "naughtyNumber",
    naughtySpecialChars: "naughtySpecialChars",
    naughtySymbols: "naughtySymbols",
    naughtyQuotes: "naughtyQuotes",
    naughtyTwoByte: "naughtyTwoByte",
    naughtyJapan: "naughtyJapan",
    naughtyEmoji: "naughtyEmoji",
    naughtyRTL: "naughtyRTL",
    naughtyTrick: "naughtyTrick",
    naughtyCorrupted: "naughtyCorrupted",
    naughtyUpDown: "naughtyUpDown",
    naughtyInjection: "naughtyInjection",
    naughtyOneOf: "naughtyOneOf"
    }};

$.ajax({
  method: "POST",
  url: "https://app.fakejson.com/q",
  data: body
  }).done(function(msg) {
    console.log(msg);
});
                                                    
                                                
                                                    
require 'uri'
require 'net/http'
require 'openssl'
require 'json'

url = URI("https://app.fakejson.com/q")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
http.verify_mode = OpenSSL::SSL::VERIFY_NONE

request = Net::HTTP::Post.new(url)
request.body = {
  token: 'YOUR-SECRET-TOKEN',
  data: {
    naughtyFalsey: 'naughtyFalsey',
    naughtyNumber: 'naughtyNumber',
    naughtySpecialChars: 'naughtySpecialChars',
    naughtySymbols: 'naughtySymbols',
    naughtyQuotes: 'naughtyQuotes',
    naughtyTwoByte: 'naughtyTwoByte',
    naughtyJapan: 'naughtyJapan',
    naughtyEmoji: 'naughtyEmoji',
    naughtyRTL: 'naughtyRTL',
    naughtyTrick: 'naughtyTrick',
    naughtyCorrupted: 'naughtyCorrupted',
    naughtyUpDown: 'naughtyUpDown',
    naughtyInjection: 'naughtyInjection',
    naughtyOneOf: 'naughtyOneOf'
  }}.to_json

response = http.request(request)
puts response.read_body
                                                    
                                                
                                                    
var request = require('request');

var body = {
  token: 'YOUR-SECRET-TOKEN',
  data: {
    naughtyFalsey: 'naughtyFalsey',
    naughtyNumber: 'naughtyNumber',
    naughtySpecialChars: 'naughtySpecialChars',
    naughtySymbols: 'naughtySymbols',
    naughtyQuotes: 'naughtyQuotes',
    naughtyTwoByte: 'naughtyTwoByte',
    naughtyJapan: 'naughtyJapan',
    naughtyEmoji: 'naughtyEmoji',
    naughtyRTL: 'naughtyRTL',
    naughtyTrick: 'naughtyTrick',
    naughtyCorrupted: 'naughtyCorrupted',
    naughtyUpDown: 'naughtyUpDown',
    naughtyInjection: 'naughtyInjection',
    naughtyOneOf: 'naughtyOneOf',
}};

request.post(
  'https://app.fakejson.com/q',
  {json: body},
  function (error, response, body) {
    if (!error && response.statusCode == 200) {
      console.log(body)
    }
  }
);
                                                    
                                                
                                                    
import requests

body = {
  'token': 'YOUR-SECRET-TOKEN',
  'data': {
    'naughtyFalsey': 'naughtyFalsey',
    'naughtyNumber': 'naughtyNumber',
    'naughtySpecialChars': 'naughtySpecialChars',
    'naughtySymbols': 'naughtySymbols',
    'naughtyQuotes': 'naughtyQuotes',
    'naughtyTwoByte': 'naughtyTwoByte',
    'naughtyJapan': 'naughtyJapan',
    'naughtyEmoji': 'naughtyEmoji',
    'naughtyRTL': 'naughtyRTL',
    'naughtyTrick': 'naughtyTrick',
    'naughtyCorrupted': 'naughtyCorrupted',
    'naughtyUpDown': 'naughtyUpDown',
    'naughtyInjection': 'naughtyInjection',
    'naughtyOneOf': 'naughtyOneOf',
}}

r = requests.post('https://app.fakejson.com/q', json = body)

                                                    
                                                
                                                    
package main

import (
  "fmt"
  "strings"
  "net/http"
  "io/ioutil"
  )

func main() {

url := "https://app.fakejson.com/q"

payload := strings.NewReader("{\"token\":\"YOUR-SECRET-TOKEN\",
\"data\":{\"naughtyFalsey\":\"naughtyFalsey\",
\"naughtyNumber\":\"naughtyNumber\",
\"naughtySpecialChars\":\"naughtySpecialChars\",
\"naughtySymbols\":\"naughtySymbols\",
\"naughtyQuotes\":\"naughtyQuotes\",
\"naughtyTwoByte\":\"naughtyTwoByte\",
\"naughtyJapan\":\"naughtyJapan\",
\"naughtyEmoji\":\"naughtyEmoji\",
\"naughtyRTL\":\"naughtyRTL\",
\"naughtyTrick\":\"naughtyTrick\",
\"naughtyCorrupted\":\"naughtyCorrupted\",
\"naughtyUpDown\":\"naughtyUpDown\",
\"naughtyInjection\":\"naughtyInjection\",
\"naughtyOneOf\":\"naughtyOneOf\"}}")

req, _ := http.NewRequest("POST", url, payload)

res, _ := http.DefaultClient.Do(req)

defer res.Body.Close()
body, _ := ioutil.ReadAll(res.Body)

fmt.Println(res)
  fmt.Println(string(body))
}
                                                    
                                                
# Color
Plans All
FakeUnits 1FK
Field Description
colorText Random Color name
colorHEX Random Color in HEX
colorRGB Random Color in RGB
colorHSL Random Color in HSL
                                                    
curl --request POST \
  --url https://app.fakejson.com/q \
  --header 'content-type: application/json' \
  --data '{
    "token": "YOUR-SECRET-TOKEN",
    "data": {
      "colorText": "colorText",
      "colorHex": "colorHex",
      "colorRGB": "colorRGB",
      "colorHSL": "colorHSL"
      }
    }'
                                                    
                                                
                                                    
var body = {
  token: "YOUR-SECRET-TOKEN",
  data: {
    colorText: "colorText",
    colorHex: "colorHex",
    colorRGB: "colorRGB",
    colorHSL: "colorHSL"
    }};

$.ajax({
  method: "POST",
  url: "https://app.fakejson.com/q",
  data: body
  }).done(function(msg) {
    console.log(msg);
});
                                                    
                                                
                                                    
require 'uri'
require 'net/http'
require 'openssl'
require 'json'

url = URI("https://app.fakejson.com/q")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
http.verify_mode = OpenSSL::SSL::VERIFY_NONE

request = Net::HTTP::Post.new(url)
request.body = {
  token: 'YOUR-SECRET-TOKEN',
  data: {
    colorText: 'colorText',
    colorHex: 'colorHex',
    colorRGB: 'colorRGB',
    colorHSL: 'colorHSL'
  }}.to_json

response = http.request(request)
puts response.read_body
                                                    
                                                
                                                    
var request = require('request');

var body = {
  token: 'YOUR-SECRET-TOKEN',
  data: {
    colorText: 'colorText',
    colorHex: 'colorHex',
    colorRGB: 'colorRGB',
    colorHSL: 'colorHSL'
}};

request.post(
  'https://app.fakejson.com/q',
  {json: body},
  function (error, response, body) {
    if (!error && response.statusCode == 200) {
      console.log(body)
    }
  }
);
                                                    
                                                
                                                    
import requests

body = {
  'token': 'YOUR-SECRET-TOKEN',
  'data': {
    'colorText': 'colorText',
    'colorHex': 'colorHex',
    'colorRGB': 'colorRGB',
    'colorHSL': 'colorHSL'
}}

r = requests.post('https://app.fakejson.com/q', json = body)

                                                    
                                                
                                                    
package main

import (
  "fmt"
  "strings"
  "net/http"
  "io/ioutil"
  )

func main() {

url := "https://app.fakejson.com/q"

payload := strings.NewReader("{\"token\":\"YOUR-SECRET-TOKEN\",
\"data\":{\"colorText\":g\"colorText\",
\"colorHex\":\"colorHex\",
\"colorRGB\":\"colorRGB\",
\"colorHSL\":\"colorHSL\"}}")

req, _ := http.NewRequest("POST", url, payload)

res, _ := http.DefaultClient.Do(req)

defer res.Body.Close()
body, _ := ioutil.ReadAll(res.Body)

fmt.Println(res)
  fmt.Println(string(body))
}
                                                    
                                                
# Currency
Plans All
FakeUnits 1FK
Field Description
currencyName Random Currency name
currencySymbol Random Currency symbol
currencyCode Random Currency code
                                                    
curl --request POST \
  --url https://app.fakejson.com/q \
  --header 'content-type: application/json' \
  --data '{
    "token": "YOUR-SECRET-TOKEN",
    "data": {
      "currencyName": "currencyName",
      "currencySymbol": "currencySymbol",
      "currencyCode": "currencyCode
      }
    }'
                                                    
                                                
                                                    
var body = {
  token: "YOUR-SECRET-TOKEN",
  data: {
    currencyName: "currencyName",
    currencySymbol: "currencySymbol",
    currencyCode: "currencyCode
    }};

$.ajax({
  method: "POST",
  url: "https://app.fakejson.com/q",
  data: body
  }).done(function(msg) {
    console.log(msg);
});
                                                    
                                                
                                                    
require 'uri'
require 'net/http'
require 'openssl'
require 'json'

url = URI("https://app.fakejson.com/q")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
http.verify_mode = OpenSSL::SSL::VERIFY_NONE

request = Net::HTTP::Post.new(url)
request.body = {
  token: 'YOUR-SECRET-TOKEN',
  data: {
    currencyName: 'currencyName',
    currencySymbol: 'currencySymbol',
    currencyCode: 'currencyCode
  }}.to_json

response = http.request(request)
puts response.read_body
                                                    
                                                
                                                    
var request = require('request');

var body = {
  token: 'YOUR-SECRET-TOKEN',
  data: {
    currencyName: 'currencyName',
    currencySymbol: 'currencySymbol',
    currencyCode: 'currencyCode
}};

request.post(
  'https://app.fakejson.com/q',
  {json: body},
  function (error, response, body) {
    if (!error && response.statusCode == 200) {
      console.log(body)
    }
  }
);
                                                    
                                                
                                                    
import requests

body = {
  'token': 'YOUR-SECRET-TOKEN',
  'data': {
    'currencyName': 'currencyName',
    'currencySymbol': 'currencySymbol',
    'currencyCode': 'currencyCode
}}

r = requests.post('https://app.fakejson.com/q', json = body)

                                                    
                                                
                                                    
package main

import (
  "fmt"
  "strings"
  "net/http"
  "io/ioutil"
  )

func main() {

url := "https://app.fakejson.com/q"

payload := strings.NewReader("{\"token\":\"YOUR-SECRET-TOKEN\",
\"data\":{\"currencyName\":\"currencyName\",
\"currencySymbol\":\"currencySymbol\",
\"currencyCode\":\"currencyCode}}")

req, _ := http.NewRequest("POST", url, payload)

res, _ := http.DefaultClient.Do(req)

defer res.Body.Close()
body, _ := ioutil.ReadAll(res.Body)

fmt.Println(res)
  fmt.Println(string(body))
}
                                                    
                                                
# Bank
Plans All
FakeUnits 1FK
Field Description
bankCCName Random Credit Card name
bankCCNumber Random Credit Card number
bankCCExpiry Random Expiry date
bankCCCVV Random CVV number
bankName Random Bank name
                                                    
curl --request POST \
  --url https://app.fakejson.com/q \
  --header 'content-type: application/json' \
  --data '{
    "token": "YOUR-SECRET-TOKEN",
    "data": {
      "bankCCName": "bankCCName",
      "bankCCNumber": "bankCCNumber",
      "bankCCExpiry": "bankCCExpiry",
      "bankCCCVV": "bankCCCVV",
      "bankName": "bankName"
      }
    }'
                                                    
                                                
                                                    
var body = {
  token: "YOUR-SECRET-TOKEN",
  data: {
    bankCCName: "bankCCName",
    bankCCNumber: "bankCCNumber",
    bankCCExpiry: "bankCCExpiry",
    bankCCCVV: "bankCCCVV",
    bankName: "bankName"
    }};

$.ajax({
  method: "POST",
  url: "https://app.fakejson.com/q",
  data: body
  }).done(function(msg) {
    console.log(msg);
});
                                                    
                                                
                                                    
require 'uri'
require 'net/http'
require 'openssl'
require 'json'

url = URI("https://app.fakejson.com/q")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
http.verify_mode = OpenSSL::SSL::VERIFY_NONE

request = Net::HTTP::Post.new(url)
request.body = {
  token: 'YOUR-SECRET-TOKEN',
  data: {
    bankCCName: 'bankCCName',
    bankCCNumber: 'bankCCNumber',
    bankCCExpiry: 'bankCCExpiry',
    bankCCCVV: 'bankCCCVV',
    bankName: 'bankName'
  }}.to_json

response = http.request(request)
puts response.read_body
                                                    
                                                
                                                    
var request = require('request');

var body = {
  token: 'YOUR-SECRET-TOKEN',
  data: {
    bankCCName: 'bankCCName',
    bankCCNumber: 'bankCCNumber',
    bankCCExpiry: 'bankCCExpiry',
    bankCCCVV: 'bankCCCVV',
    bankName: 'bankName'
}};

request.post(
  'https://app.fakejson.com/q',
  {json: body},
  function (error, response, body) {
    if (!error && response.statusCode == 200) {
      console.log(body)
    }
  }
);
                                                    
                                                
                                                    
import requests

body = {
  'token': 'YOUR-SECRET-TOKEN',
  'data': {
    'bankCCName': 'bankCCName',
    'bankCCNumber': 'bankCCNumber',
    'bankCCExpiry': 'bankCCExpiry',
    'bankCCCVV': 'bankCCCVV',
    'bankName': 'bankName'
}}

r = requests.post('https://app.fakejson.com/q', json = body)

                                                    
                                                
                                                    
package main

import (
  "fmt"
  "strings"
  "net/http"
  "io/ioutil"
  )

func main() {

url := "https://app.fakejson.com/q"

payload := strings.NewReader("{\"token\":\"YOUR-SECRET-TOKEN\",
\"data\":{\"bankCCName\":\"bankCCName\",
\"bankCCNumber\":\"bankCCNumber\",
\"bankCCExpiry\":\"bankCCExpiry\",
\"bankCCCVV\":\"bankCCCVV\",
\"bankName\":\"bankName\"}}")

req, _ := http.NewRequest("POST", url, payload)

res, _ := http.DefaultClient.Do(req)

defer res.Body.Close()
body, _ := ioutil.ReadAll(res.Body)

fmt.Println(res)
  fmt.Println(string(body))
}
                                                    
                                                
# File
Plans All
FakeUnits 1FK
Field Description
fileName Random File name
fileExtension Random File extension
fileMIME Random File MIME type
                                                    
curl --request POST \
  --url https://app.fakejson.com/q \
  --header 'content-type: application/json' \
  --data '{
    "token": "YOUR-SECRET-TOKEN",
    "data": {
      "fileName": "fileName",
      "fileExtension": "fileExtension",
      "fileMIME": "fileMIME"
      }
    }'
                                                    
                                                
                                                    
var body = {
  token: "YOUR-SECRET-TOKEN",
  data: {
    fileName: "fileName",
    fileExtension: "fileExtension",
    fileMIME: "fileMIME"
    }};

$.ajax({
  method: "POST",
  url: "https://app.fakejson.com/q",
  data: body
  }).done(function(msg) {
    console.log(msg);
});
                                                    
                                                
                                                    
require 'uri'
require 'net/http'
require 'openssl'
require 'json'

url = URI("https://app.fakejson.com/q")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
http.verify_mode = OpenSSL::SSL::VERIFY_NONE

request = Net::HTTP::Post.new(url)
request.body = {
  token: 'YOUR-SECRET-TOKEN',
  data: {
    fileName: 'fileName',
    fileExtension: 'fileExtension',
    fileMIME: 'fileMIME'
  }}.to_json

response = http.request(request)
puts response.read_body
                                                    
                                                
                                                    
var request = require('request');

var body = {
  token: 'YOUR-SECRET-TOKEN',
  data: {
    fileName: 'fileName',
    fileExtension: 'fileExtension',
    fileMIME: 'fileMIME'
}};

request.post(
  'https://app.fakejson.com/q',
  {json: body},
  function (error, response, body) {
    if (!error && response.statusCode == 200) {
      console.log(body)
    }
  }
);
                                                    
                                                
                                                    
import requests

body = {
  'token': 'YOUR-SECRET-TOKEN',
  'data': {
    'fileName': 'fileName',
    'fileExtension': 'fileExtension',
    'fileMIME': 'fileMIME'
}}

r = requests.post('https://app.fakejson.com/q', json = body)

                                                    
                                                
                                                    
package main

import (
  "fmt"
  "strings"
  "net/http"
  "io/ioutil"
  )

func main() {

url := "https://app.fakejson.com/q"

payload := strings.NewReader("{\"token\":\"YOUR-SECRET-TOKEN\",
\"data\":{\"fileName\":\"fileName\",
\"fileExtension\":\"fileExtension\",
\"fileMIME\":\"fileMIME\"}}")

req, _ := http.NewRequest("POST", url, payload)

res, _ := http.DefaultClient.Do(req)

defer res.Body.Close()
body, _ := ioutil.ReadAll(res.Body)

fmt.Println(res)
  fmt.Println(string(body))
}
                                                    
                                                
# Crypto
Plans All
FakeUnits 1FK

Warning Do not use these functions for any of your cryptographic needs. These are not cryptographically strong.

Field Description
cryptoUUID Random UUID v4
cryptoMD5 Random MD5 hash
cryptoSHA Random SHA hash
cryptoSHA224 Random SHA224 hash
cryptoSHA256 Random SHA256 hash
cryptoSHA384 Random SHA384 hash
cryptoSHA512 Random SHA512 hash
                                                    
curl --request POST \
  --url https://app.fakejson.com/q \
  --header 'content-type: application/json' \
  --data '{
    "token": "YOUR-SECRET-TOKEN",
    "data": {
      "cryptoUUID": "cryptoUUID",
      "cryptoMD5": "cryptoMD5",
      "cryptoSHA": "cryptoSHA",
      "cryptoSHA224": "cryptoSHA224",
      "cryptoSHA256": "cryptoSHA256",
      "cryptoSHA384": "cryptoSHA384",
      "cryptoSHA512": "cryptoSHA512"
      }
    }'
                                                    
                                                
                                                    
var body = {
  token: "YOUR-SECRET-TOKEN",
  data: {
    cryptoUUID: "cryptoUUID",
    cryptoMD5: "cryptoMD5",
    cryptoSHA: "cryptoSHA",
    cryptoSHA224: "cryptoSHA224",
    cryptoSHA256: "cryptoSHA256",
    cryptoSHA384: "cryptoSHA384",
    cryptoSHA512: "cryptoSHA512"
    }};

$.ajax({
  method: "POST",
  url: "https://app.fakejson.com/q",
  data: body
  }).done(function(msg) {
    console.log(msg);
});
                                                    
                                                
                                                    
require 'uri'
require 'net/http'
require 'openssl'
require 'json'

url = URI("https://app.fakejson.com/q")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
http.verify_mode = OpenSSL::SSL::VERIFY_NONE

request = Net::HTTP::Post.new(url)
request.body = {
  token: 'YOUR-SECRET-TOKEN',
  data: {
    cryptoUUID: 'cryptoUUID',
    cryptoMD5: 'cryptoMD5',
    cryptoSHA: 'cryptoSHA',
    cryptoSHA224: 'cryptoSHA224',
    cryptoSHA256: 'cryptoSHA256',
    cryptoSHA384: 'cryptoSHA384',
    cryptoSHA512: 'cryptoSHA512'
  }}.to_json

response = http.request(request)
puts response.read_body
                                                    
                                                
                                                    
var request = require('request');

var body = {
  token: 'YOUR-SECRET-TOKEN',
  data: {
    cryptoUUID: 'cryptoUUID',
    cryptoMD5: 'cryptoMD5',
    cryptoSHA: 'cryptoSHA',
    cryptoSHA224: 'cryptoSHA224',
    cryptoSHA256: 'cryptoSHA256',
    cryptoSHA384: 'cryptoSHA384',
    cryptoSHA512: 'cryptoSHA512'
}};

request.post(
  'https://app.fakejson.com/q',
  {json: body},
  function (error, response, body) {
    if (!error && response.statusCode == 200) {
      console.log(body)
    }
  }
);
                                                    
                                                
                                                    
import requests

body = {
  'token': 'YOUR-SECRET-TOKEN',
  'data': {
    'cryptoUUID': 'cryptoUUID',
    'cryptoMD5': 'cryptoMD5',
    'cryptoSHA': 'cryptoSHA',
    'cryptoSHA224': 'cryptoSHA224',
    'cryptoSHA256': 'cryptoSHA256',
    'cryptoSHA384': 'cryptoSHA384',
    'cryptoSHA512': 'cryptoSHA512'
}}

r = requests.post('https://app.fakejson.com/q', json = body)

                                                    
                                                
                                                    
package main

import (
  "fmt"
  "strings"
  "net/http"
  "io/ioutil"
  )

func main() {

url := "https://app.fakejson.com/q"

payload := strings.NewReader("{\"token\":\"YOUR-SECRET-TOKEN\",
\"data\":{\"cryptoUUID\":\"cryptoUUID\",
\"cryptoMD5\":\"cryptoMD5\",
\"cryptoSHA\":\"cryptoSHA\",
\"cryptoSHA224\":\"cryptoSHA224\",
\"cryptoSHA256\":\"cryptoSHA256\",
\"cryptoSHA384\":\"cryptoSHA384\",
\"cryptoSHA512\":\"cryptoSHA512\"}}")

req, _ := http.NewRequest("POST", url, payload)

res, _ := http.DefaultClient.Do(req)

defer res.Body.Close()
body, _ := ioutil.ReadAll(res.Body)

fmt.Println(res)
  fmt.Println(string(body))
}
                                                    
                                                
# Person
Plans All
FakeUnits 1FK
Field Description
personNickname Random Nickname
personGender Person Gender
personAvatar Link to random robohash avatar
personPassword Random simple online password
personMaritalStatus Marital Status
personLanguage Random Language
personSkill Random professional skill
personTitle Position Titles
personDegree Random Degree
                                                    
curl --request POST \
  --url https://app.fakejson.com/q \
  --header 'content-type: application/json' \
  --data '{
    "token": "YOUR-SECRET-TOKEN",
    "data": {
      "personNickname": "personNickname",
      "personGender": "personGender",
      "personAvatar": "personAvatar",
      "personPassword": "personPassword",
      "personMaritalStatus": "personMaritalStatus",
      "personLanguage": "personLanguage",
      "personSkill": "personSkill",
      "personTitle": "personTitle",
      "personDegree": "personDegree"
      }
    }'
                                                    
                                                
                                                    
var body = {
  token: "YOUR-SECRET-TOKEN",
  data: {
    personNickname: "personNickname",
    personGender: "personGender",
    personAvatar: "personAvatar",
    personPassword: "personPassword",
    personMaritalStatus: "personMaritalStatus",
    personLanguage: "personLanguage",
    personSkill: "personSkill",
    personTitle: "personTitle",
    personDegree: "personDegree"
    }};

$.ajax({
  method: "POST",
  url: "https://app.fakejson.com/q",
  data: body
  }).done(function(msg) {
    console.log(msg);
});
                                                    
                                                
                                                    
require 'uri'
require 'net/http'
require 'openssl'
require 'json'

url = URI("https://app.fakejson.com/q")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
http.verify_mode = OpenSSL::SSL::VERIFY_NONE

request = Net::HTTP::Post.new(url)
request.body = {
  token: 'YOUR-SECRET-TOKEN',
  data: {
    personNickname: 'personNickname',
    personGender: 'personGender',
    personAvatar: 'personAvatar',
    personPassword: 'personPassword',
    personMaritalStatus: 'personMaritalStatus',
    personLanguage: 'personLanguage',
    personSkill: 'personSkill',
    personTitle: 'personTitle',
    personDegree: 'personDegree'
  }}.to_json

response = http.request(request)
puts response.read_body
                                                    
                                                
                                                    
var request = require('request');

var body = {
  token: 'YOUR-SECRET-TOKEN',
  data: {
    personNickname: 'personNickname',
    personGender: 'personGender',
    personAvatar: 'personAvatar',
    personPassword: 'personPassword',
    personMaritalStatus: 'personMaritalStatus',
    personLanguage: 'personLanguage',
    personSkill: 'personSkill',
    personTitle: 'personTitle',
    personDegree: 'personDegree'
}};

request.post(
  'https://app.fakejson.com/q',
  {json: body},
  function (error, response, body) {
    if (!error && response.statusCode == 200) {
      console.log(body)
    }
  }
);
                                                    
                                                
                                                    
import requests

body = {
  'token': 'YOUR-SECRET-TOKEN',
  'data': {
    'personNickname': 'personNickname',
    'personGender': 'personGender',
    'personAvatar': 'personAvatar',
    'personPassword': 'personPassword',
    'personMaritalStatus': 'personMaritalStatus',
    'personLanguage': 'personLanguage',
    'personSkill': 'personSkill',
    'personTitle': 'personTitle',
    'personDegree': 'personDegree'
}}

r = requests.post('https://app.fakejson.com/q', json = body)

                                                    
                                                
                                                    
package main

import (
  "fmt"
  "strings"
  "net/http"
  "io/ioutil"
  )

func main() {

url := "https://app.fakejson.com/q"

payload := strings.NewReader("{\"token\":\"YOUR-SECRET-TOKEN\",
\"data\":{\"personNickname\":\"personNickname\",
\"personGender\":\"personGender\",
\"personAvatar\":\"personAvatar\",
\"personPassword\":\"personPassword\",
\"personMaritalStatus\":\"personMaritalStatus\",
\"personLanguage\":\"personLanguage\",
\"personSkill\":\"personSkill\",
\"personTitle\":\"personTitle\",
\"personDegree\":\"personDegree\"}}")

req, _ := http.NewRequest("POST", url, payload)

res, _ := http.DefaultClient.Do(req)

defer res.Body.Close()
body, _ := ioutil.ReadAll(res.Body)

fmt.Println(res)
  fmt.Println(string(body))
}
                                                    
                                                
# Commerce
Plans All
FakeUnits 1FK
Field Description Sample Values
productName Random product name Kanjob, Temptop
productSize Random product size XS, XL
productOrderStatus Random status delayed, cancelled
                                                    
curl --request POST \
  --url https://app.fakejson.com/q \
  --header 'content-type: application/json' \
  --data '{
    "token": "YOUR-SECRET-TOKEN",
    "data": {
      "productName": "productName",
      "productSize": "productSize",
      "productOrderStatus": "productOrderStatus"
      }
    }'
                                                    
                                                
                                                    
var body = {
  token: "YOUR-SECRET-TOKEN",
  data: {
    productName: "productName",
    productSize: "productSize",
    productOrderStatus: "productOrderStatus"
    }};

$.ajax({
  method: "POST",
  url: "https://app.fakejson.com/q",
  data: body
  }).done(function(msg) {
    console.log(msg);
});
                                                    
                                                
                                                    
require 'uri'
require 'net/http'
require 'openssl'
require 'json'

url = URI("https://app.fakejson.com/q")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
http.verify_mode = OpenSSL::SSL::VERIFY_NONE

request = Net::HTTP::Post.new(url)
request.body = {
  token: 'YOUR-SECRET-TOKEN',
  data: {
    productName: 'productName',
    productSize: 'productSize',
    productOrderStatus: 'productOrderStatus'
  }}.to_json

response = http.request(request)
puts response.read_body
                                                    
                                                
                                                    
var request = require('request');

var body = {
  token: 'YOUR-SECRET-TOKEN',
  data: {
    productName: 'productName',
    productSize: 'productSize',
    productOrderStatus: 'productOrderStatus'
}};

request.post(
  'https://app.fakejson.com/q',
  {json: body},
  function (error, response, body) {
    if (!error && response.statusCode == 200) {
      console.log(body)
    }
  }
);
                                                    
                                                
                                                    
import requests

body = {
  'token': 'YOUR-SECRET-TOKEN',
  'data': {
    'productName': 'productName',
    'productSize': 'productSize',
    'productOrderStatus': 'productOrderStatus'
}}

r = requests.post('https://app.fakejson.com/q', json = body)

                                                    
                                                
                                                    
package main

import (
  "fmt"
  "strings"
  "net/http"
  "io/ioutil"
  )

func main() {

url := "https://app.fakejson.com/q"

payload := strings.NewReader("{\"token\":\"YOUR-SECRET-TOKEN\",
\"data\":{\"productName\":g\"productName\",
\"productSize\":\"productSize\",
\"productOrderStatus\":\"productOrderStatus\"}}")

req, _ := http.NewRequest("POST", url, payload)

res, _ := http.DefaultClient.Do(req)

defer res.Body.Close()
body, _ := ioutil.ReadAll(res.Body)

fmt.Println(res)
  fmt.Println(string(body))
}
                                                    
                                                
# Company
Plans All
FakeUnits 1FK
Field Description
companyName Random Company Name
companyDepartment Random Department within Company
companyIndustry Industry
                                                    
curl --request POST \
  --url https://app.fakejson.com/q \
  --header 'content-type: application/json' \
  --data '{
    "token": "YOUR-SECRET-TOKEN",
    "data": {
      "companyName": "companyName",
      "companyDepartment": "companyDepartment",
      "companyIndustry": "companyIndustry"
      }
    }'
                                                    
                                                
                                                    
var body = {
  token: "YOUR-SECRET-TOKEN",
  data: {
    companyName: "companyName",
    companyDepartment: "companyDepartment",
    companyIndustry: "companyIndustry"
    }};

$.ajax({
  method: "POST",
  url: "https://app.fakejson.com/q",
  data: body
  }).done(function(msg) {
    console.log(msg);
});
                                                    
                                                
                                                    
require 'uri'
require 'net/http'
require 'openssl'
require 'json'

url = URI("https://app.fakejson.com/q")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
http.verify_mode = OpenSSL::SSL::VERIFY_NONE

request = Net::HTTP::Post.new(url)
request.body = {
  token: 'YOUR-SECRET-TOKEN',
  data: {
    companyName: 'companyName',
    companyDepartment: 'companyDepartment',
    companyIndustry: 'companyIndustry'
  }}.to_json

response = http.request(request)
puts response.read_body
                                                    
                                                
                                                    
var request = require('request');

var body = {
  token: 'YOUR-SECRET-TOKEN',
  data: {
    companyName: 'companyName',
    companyDepartment: 'companyDepartment',
    companyIndustry: 'companyIndustry'
}};

request.post(
  'https://app.fakejson.com/q',
  {json: body},
  function (error, response, body) {
    if (!error && response.statusCode == 200) {
      console.log(body)
    }
  }
);
                                                    
                                                
                                                    
import requests

body = {
  'token': 'YOUR-SECRET-TOKEN',
  'data': {
    'companyName': 'companyName',
    'companyDepartment': 'companyDepartment',
    'companyIndustry': 'companyIndustry'
}}

r = requests.post('https://app.fakejson.com/q', json = body)

                                                    
                                                
                                                    
package main

import (
  "fmt"
  "strings"
  "net/http"
  "io/ioutil"
  )

func main() {

url := "https://app.fakejson.com/q"

payload := strings.NewReader("{\"token\":\"YOUR-SECRET-TOKEN\",
\"data\":{\"companyName\":\"companyName\",
\"companyDepartment\":\"companyDepartment\",
\"companyIndustry\":\"companyIndustry\"}}")

req, _ := http.NewRequest("POST", url, payload)

res, _ := http.DefaultClient.Do(req)

defer res.Body.Close()
body, _ := ioutil.ReadAll(res.Body)

fmt.Println(res)
  fmt.Println(string(body))
}
                                                    
                                                
# Customer
Plans All
FakeUnits 1FK
Field Description
customerTier Plan selected by customer
customerStatus Status of customer
                                                    
curl --request POST \
  --url https://app.fakejson.com/q \
  --header 'content-type: application/json' \
  --data '{
    "token": "YOUR-SECRET-TOKEN",
    "data": {
      "customerTier": "customerTier",
      "customerStatus": "customerStatus"
      }
    }'
                                                    
                                                
                                                    
var body = {
  token: "YOUR-SECRET-TOKEN",
  data: {
    customerTier: "customerTier",
    customerStatus: "customerStatus"
    }};

$.ajax({
  method: "POST",
  url: "https://app.fakejson.com/q",
  data: body
  }).done(function(msg) {
    console.log(msg);
});
                                                    
                                                
                                                    
require 'uri'
require 'net/http'
require 'openssl'
require 'json'

url = URI("https://app.fakejson.com/q")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
http.verify_mode = OpenSSL::SSL::VERIFY_NONE

request = Net::HTTP::Post.new(url)
request.body = {
  token: 'YOUR-SECRET-TOKEN',
  data: {
    customerTier: 'customerTier',
    customerStatus: 'customerStatus'
  }}.to_json

response = http.request(request)
puts response.read_body
                                                    
                                                
                                                    
var request = require('request');

var body = {
  token: 'YOUR-SECRET-TOKEN',
  data: {
    customerTier: 'customerTier',
    customerStatus: 'customerStatus'
}};

request.post(
  'https://app.fakejson.com/q',
  {json: body},
  function (error, response, body) {
    if (!error && response.statusCode == 200) {
      console.log(body)
    }
  }
);
                                                    
                                                
                                                    
import requests

body = {
  'token': 'YOUR-SECRET-TOKEN',
  'data': {
    'customerTier': 'customerTier',
    'customerStatus': 'customerStatus'
}}

r = requests.post('https://app.fakejson.com/q', json = body)

                                                    
                                                
                                                    
package main

import (
  "fmt"
  "strings"
  "net/http"
  "io/ioutil"
  )

func main() {

url := "https://app.fakejson.com/q"

payload := strings.NewReader("{\"token\":\"YOUR-SECRET-TOKEN\",
\"data\":{\"customerTier\":g\"customerTier\",
\"customerStatus\":\"customerStatus\"}}")

req, _ := http.NewRequest("POST", url, payload)

res, _ := http.DefaultClient.Do(req)

defer res.Body.Close()
body, _ := ioutil.ReadAll(res.Body)

fmt.Println(res)
  fmt.Println(string(body))
}
                                                    
                                                
# Other
Plans All
FakeUnits 1FK
Field Description
otherInsult Random Insults...
otherBuzzWord Business buzzword
otherCatchPhrase Business catch phrase
                                                    
curl --request POST \
  --url https://app.fakejson.com/q \
  --header 'content-type: application/json' \
  --data '{
    "token": "YOUR-SECRET-TOKEN",
    "data": {
      "otherInsult": "otherInsult",
      "otherBuzzWord": "otherBuzzWord",
      "otherCatchPhrase": "otherCatchPhrase"
      }
    }'
                                                    
                                                
                                                    
var body = {
  token: "YOUR-SECRET-TOKEN",
  data: {
    otherInsult: "otherInsult",
    otherBuzzWord: "otherBuzzWord",
    otherCatchPhrase: "otherCatchPhrase"
    }};

$.ajax({
  method: "POST",
  url: "https://app.fakejson.com/q",
  data: body
  }).done(function(msg) {
    console.log(msg);
});
                                                    
                                                
                                                    
require 'uri'
require 'net/http'
require 'openssl'
require 'json'

url = URI("https://app.fakejson.com/q")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
http.verify_mode = OpenSSL::SSL::VERIFY_NONE

request = Net::HTTP::Post.new(url)
request.body = {
  token: 'YOUR-SECRET-TOKEN',
  data: {
    otherInsult: 'otherInsult',
    otherBuzzWord: 'otherBuzzWord',
    otherCatchPhrase: 'otherCatchPhrase'
  }}.to_json

response = http.request(request)
puts response.read_body
                                                    
                                                
                                                    
var request = require('request');

var body = {
  token: 'YOUR-SECRET-TOKEN',
  data: {
    otherInsult: 'otherInsult',
    otherBuzzWord: 'otherBuzzWord',
    otherCatchPhrase: 'otherCatchPhrase'
}};

request.post(
  'https://app.fakejson.com/q',
  {json: body},
  function (error, response, body) {
    if (!error && response.statusCode == 200) {
      console.log(body)
    }
  }
);
                                                    
                                                
                                                    
import requests

body = {
  'token': 'YOUR-SECRET-TOKEN',
  'data': {
    'otherInsult': 'otherInsult',
    'otherBuzzWord': 'otherBuzzWord',
    'otherCatchPhrase': 'otherCatchPhrase'
}}

r = requests.post('https://app.fakejson.com/q', json = body)

                                                    
                                                
                                                    
package main

import (
  "fmt"
  "strings"
  "net/http"
  "io/ioutil"
  )

func main() {

url := "https://app.fakejson.com/q"

payload := strings.NewReader("{\"token\":\"YOUR-SECRET-TOKEN\",
\"data\":{\"otherInsult\":\"otherInsult\",
\"otherBuzzWord\":\"otherBuzzWord\",
\"otherCatchPhrase\":\"otherCatchPhrase\"}}")

req, _ := http.NewRequest("POST", url, payload)

res, _ := http.DefaultClient.Do(req)

defer res.Body.Close()
body, _ := ioutil.ReadAll(res.Body)

fmt.Println(res)
  fmt.Println(string(body))
}
                                                    
                                                
# Bundle

Bundles are predefined structures to speed up mock api generation. They are simply a combination of fields that define most common use cases. Bundles cost in Fake Json units is equal to the number of fields in the bundle.

bundleUser
Plans All
FakeUnits 6FK
                                
"user": {
    "first_name": "nameFirst",
    "last_name": "nameLast",
    "email": "internetEmail",
    "nickname": "personNickname",
    "password": "personPassword",
    "avatar": "personAvatar"
}
                                
                            
bundleAddress
Plans All
FakeUnits 6FK
                                
"address": {
    "building": "addressBuilding",
    "street": "addressFullStreet",
    "city": "addressCity",
    "state": "addressState",
    "country": "addressCountry",
    "zip": "addressZipCode"
}
                                
                            
bundleCC
Plans All
FakeUnits 4FK
                                
"credit_card": {
    "number": "bankCCNumber",
    "cvv": "bankCCCVV",
    "expiry": "bankCCExpiry",
    "type": "bankCCName"
}
                                
                            
# Custom
Plans DEVELOPER, SMALL TEAM, BIG TEAM
FakeUnits Variable

Custom fields are different from customizable fields you may have encountered above. Custom fields allow you to create your own custom string according to your own defined format. You can do so using any combination of the fields discussed previously. There is no restriction on how many fields you may use within a custom field. To add a field as a parameter to your your custom field, all you have to do is to include the field name within double curly brackets like so {{nameFirst}}. The double curly bracket fields will be replaced with random values according to the field specifications.

Example custom field:

customString|Hello, my name is {{nameFirst}}, my email address is {{internetEmail}}, and I live in {{addressCountry}}. Double curly bracket fields will be replaced with random values according to field rules.

Possible response:

Hello, my name is Richmond, my email address is aurore@gmail.com, and I live in Uzbekistan

# Functions
Plans All
FakeUnits Variable

Functions are a special set of fields that allow you to customize responses even further.

functionArray

Array function lets you modify any of the fields to be returned as array/list of values. For example, you need to have a large set of float numbers returned as one array, you can do it by prefixing numberFloat field with functionArray keyphrase.

Example:

                                
{
  "data": {
    "bigListOfFloats": "functionArray|10|numberFloat"
   }
}
                                
                            

Result:

                                
{
  "bigListOfFloats": [
    371.53,
    540.3,
    902.97,
    982.75,
    989.52,
    718.28,
    156.04,
    602.42,
    58.86,
    909.21
  ]
}
                                
                            

Syntax of functionArray function is always the same and is strict. If function did not match exactly it will be ignored, and simply a value of the field will be returned. functionArray field is also limited by "Items in array" permission of the plan you have selected.

functionArray always has one parameter, which is a a positive integer, followed by the field name to put into array, like so:

functionArray|20|nameFirst

You can use fields with customizations too, like so:

functionArray|30|numberFloat|3,20|6

As you can see format always remains consistent.

Saved Resources

Plans DEVELOPER, SMALL TEAM, BIG TEAM

Easily access, modify and use your favorite resources with the 'Saved resources' feature. A saved resource is similar to a regular fakeJSON request. They both revolve around the same endpoint: app.fakejson.com/q. The difference? Saved resources have a handy shortened ID that tells fakeJSON everything it needs to know about your request. Long story short, the long request becomes short.


# New Resource

The first step to creating a saved resource is to create it. Navigate to the "Saved resources" section of your member interface. Click either the "+" button or the "Create your first resource" if this is your first saved resource. You can name the saved resource anything you like as well as provide a description for it. Enter your resource request without the token in the query field. Example below:

                                
{
  "parameters": {
    "code": 200
  },
  "data": {
    "user_name": "nameFirst",
    "user_email": "internetEmail"
  }
}
                                
                            

The token is not required as it has to be included when a request is made. All other fields behave the same way as before.

Save the resource and your're done!

# Using the Resource

Using your saved resource is as simple as copying it and using a GET, POST, PUT, PATCH or DELETE method. Notice that with saved resources, you can now use the GET method. Try it out by clicking on the button to open the resource in a new window.

Resource will be accessible at app.fakejson.com/q/[resource-ID] until you delete this resource. You can include the token as part of the request payload, or as a query string parameter like so: app.fakejson.com/q/[resource-ID]?token=YOUR-SECRET-TOKEN

# Modifying the Resource

If for some reason you decide to modify your saved resource, you have two options. Modify the saved resource in your fakeJSON account or modify it directly when making a saved resource request. There are pros and cons to both approaches.

  1. Modify saved resource in fakeJSON member area

    Pro: Changes made are saved to the resource itself.
    Con: You have to enter the member area to make the change

  2. Modify the saved resource request directly

    Pro: You can make changes on the fly as you are making API requests. You can choose to add new parameters or data fields or overwrite existing matching ones. For example, if you wanted to add a new response code to the request, you would just add {"parameters":{"code": 404}}. Or if you already had a response code and you wanted to change it, you would just add the new response code like so {"parameters":{"code": 501}}.
    Con: Changes made don't get saved to the resource itself. If this is a change you think will be repeated many times, you should probably go with option 1.

fakeJSON Library

Plans ALL

Get started with fakeJSON's mock front end library, a library for building realistic looking mockups quicker and with less effort. Directly populate HTML with random data using just the fakeJSON mock front end library, powered by the fakeJSON API.

# How to use

Looking to quickly add fakeJSON mock data to your application? Simply copy and paste these two script tags into your application's <head> and replace the token reference with your actual fakeJSON token. It works even with plain JavaScript.

                                
<script>var fj_token = "YOUR-SECRET-TOKEN";</script>
<script src="https://fakejson.com/fakejson.min.js" async></script>
                                
                            

Here's a starter page template with the two script tags included

                                
<!DOCTYPE HTML>
<html lang="en">
<head>
    <script>var fj_token = "YOUR-SECRET-TOKEN";</script>
    <script src="https://fakejson.com/fakejson.min.js" async></script>
</head>
<body>
    <h1>My Page</h1>
</body>
</html>
                                
                            

Once you've included the two script tags, you can immediately start your development work. Simply specify which element you'd like to populate with test data and the library will do the rest. You do this by adding a data-fj attribute to the target HTML element. Below is a simple example of a HTML page where its H1 and P elements are populated with test data.

                                
<!DOCTYPE HTML>
<html lang="en">
<head>
    <script>var fj_token = "YOUR-SECRET-TOKEN";</script>
    <script src="https://fakejson.com/fakejson.min.js" async></script>
</head>
<body>
    <h1 data-fj="nameFirst">My Page</h1>
    <p data-fj="stringShort|5,20">Text Content</p>
</body>
</html>
                                
                            
# Static Error Routes

Static error routes allow you to get HTTP error responses without any hassle. Simply point request to https://fakejson.com/errors/{error #} and you will get appropriate error response.

400 and 500 errors are supported.