Mockaroo APIs

GET  https://api.mockaroo.com/api/types?key=(your API key)

POST  https://api.mockaroo.com/api/datasets/:name?key=(your API key)&filename=(file name)

const fs = require('fs')

function upload(apiKey, name, path) {
  fetch(
    `https://api.mockaroo.com/api/datasets/${encodeURIComponent(
      name
    )}?key=${encodeURIComponent(apiKey)}`,
    {
      method: 'post',
      body: fs.readFileSync(path),
      headers: {
        'content-type': 'text/csv',
      },
    }
  )
    .then(res => res.json())
    .then(result => console.log(result))
}

POST  https://api.mockaroo.com/api/datasets?key=(your API key)&name=(dataset name)&filename=(file name)

const fetch = require('node-fetch')
const fs = require('fs')

function destroy(apiKey, name, path) {
  fetch(
    `https://api.mockaroo.com/api/datasets/${encodeURIComponent(
      name
    )}?key=${encodeURIComponent(apiKey)}`,
    {
      method: 'delete',
    }
  )
    .then(res => res.json())
    .then(result => console.log(result))
}

POST  https://api.mockaroo.com/api/generate(.format)?key=(your API key)

{
  "downloadId": number // The id of the background job. Pass this to /api/downloads/:id to get the status of the job and access the generated data when finished.
}

{
  "status": string,             // "success", "failed", "queued", or "in_progress"
  "error": string,              // the error message if the status is failed
  "recordsGenerated": number,   // the number of records generated so far
  "percentComplete": number,    // the percentage of total records generated so far
  "url": string                 // the URL from which the generated data can be downloaded
}

{
  "error": string // The error message
}

import Mockaroo from 'mockaroo' // npm install mockaroo

const client = new Mockaroo.Client({
  apiKey: process.env.MOCKAROO_API_KEY, // your API key
})

client
  .generate({
    count: 10,
    fields: [
      {
        name: 'id',
        type: 'Row Number',
      },
      {
        name: 'transactionType',
        type: 'Custom List',
        values: ['credit', 'debit'],
      },
    ],
  })
  .then(function (records) {
    for (var i = 0; i < records.length; i++) {
      var record = records[i]
      console.log(
        'record ' + i,
        'id:' + record.id + ', transactionType:' + record.transactionType
      )
    }
  })

import got from 'got'
import { promisify } from 'node:util'
import stream from 'node:stream'
import fs from 'node:fs'

const urlBase = `https://api.mockaroo.com`
const apiKey = process.env.MOCKAROO_API_KEY
const schema = 'My Schema'
const count = 10000
const dest = 'data.csv'

async function main() {
  try {
    // Start generating data in the background
    const { downloadId } = await start(schema, count)

    // Poll until it's done.
    const { url } = await poll(downloadId)

    // Download the generated file
    await download(url, dest)
  } catch (e) {
    console.log(`Failed: ${e.message}`)
  }

  process.exit(0)
}

/**
 * Starts data generation in the background.
 */
async function start(schema, count) {
  const url =
    `${urlBase}/api/generate.csv?background=true` +
    `&schema=${encodeURIComponent(schema)}` +
    `&count=${count}`

  return await fetchAuthenticated(url)
}

/**
 * Makes an authenticated fetch by passing your Mockaroo API key via the X-Api-Key header.
 */
function fetchAuthenticated(url, { headers, ...options } = { headers: {} }) {
  return got(url, {
    ...options,
    headers: {
      ...headers,
      'X-Api-Key': apiKey,
    },
  }).json()
}

/**
 * Polls every second to determine when data generation has completed.
 * @param {number} id The download id
 * @returns {Object} The API response body when data generation is completed.
 */
async function poll(id) {
  return new Promise((resolve, reject) => {
    setInterval(async () => {
      const url = `${urlBase}/api/downloads/${id}`
      const result = await fetchAuthenticated(url)

      if (result.status === 'success') {
        resolve(result)
      } else if (result.status === 'failed') {
        reject(new Error(result.error))
      } else if (result.status === 'queued') {
        console.log(
          `queued behind ${result.position} other${
            result.position === 1 ? '' : 's'
          }...`
        )
      } else {
        console.log(
          `${result.recordsGenerated} (${result.percentComplete}%)...`
        )
      }
    }, 1000)
  })
}

/**
 * Downloads the specified url to the dest file path
 * @param {*} url The URL to download
 * @param {*} file The file path to write it to
 */
async function download(url, dest) {
  console.log(`downloading to ${dest}...`)
  const pipeline = promisify(stream.pipeline)
  await pipeline(got.stream(url), fs.createWriteStream(dest))
}

main()

const fields = [
  {
    name: 'yearsEmployed',
    type: 'Number',
    min: 1,
    max: 30,
    decimals: 0,
  },
  {
    name: 'department',
    type: 'Custom List',
    values: ['R+D', 'Marketing', 'HR'],
  },
  {
    name: 'dob',
    type: 'Date',
    min: '1/1/1950',
    max: '1/1/2000',
    format: '%m/%d/%Y',
  },
]

const key = process.env.MOCKAROO_API_KEY // Your mockaroo API key

const url = `https://api.mockaroo.com/api/generate.json?key=${key}&fields=${encodeURIComponent(
  JSON.stringify(fields)
)}`

$.ajax(url, {
  dataType: 'jsonp',
  contentType: 'application/json',
  success: function (data) {
    console.log('yearsEmployed', data.yearsEmployed)
    console.log('department', data.department)
    console.log('dob', data.dob)
  },
})

package com.mockaroo.api.example;

import org.apache.commons.io.IOUtils;
import org.json.JSONArray;
import org.json.JSONObject;

import java.io.IOException;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;

public class Client {
	public static void main(String[] args) throws IOException {
		URL url = new URL("https://api.mockaroo.com/api/generate.json?key=abcd1234");
		HttpURLConnection conn = (HttpURLConnection) url.openConnection();
		conn.setDoOutput(true);
		conn.setRequestMethod("POST");
		conn.setRequestProperty("Content-Type", "application/json");

		JSONObject yearsEmployed = new JSONObject();
		yearsEmployed.put("name", "yearsEmployed");
		yearsEmployed.put("type", "Number");
		yearsEmployed.put("min", 1);
		yearsEmployed.put("max", 30);
		yearsEmployed.put("decimals", 0);

		JSONObject department = new JSONObject();
		department.put("name", "department");
		department.put("type", "Custom List");
		JSONArray values = new JSONArray();
		values.put("R+D");
		values.put("Marketing");
		values.put("HR");
		department.put("values", values);

		JSONObject dob = new JSONObject();
		dob.put("name", "dob");
		dob.put("type", "Date");
		dob.put("min", "1/1/1950");
		dob.put("max", "1/1/2000");
		dob.put("format", "%m/%d/%Y");

		JSONArray fields = new JSONArray();
		fields.put(yearsEmployed);
		fields.put(department);
		fields.put(dob);

		OutputStream os = conn.getOutputStream();
		os.write(fields.toString().getBytes());
		os.flush();

		JSONObject data = new JSONObject(IOUtils.toString(conn.getInputStream()));

		System.out.println(data.getInt("yearsEmployed"));
		System.out.println(data.getString("department"));
		System.out.println(data.getString("dob"));
	}
}