DEV Community: Ismail Kamil

Tool	Key Features	Supported Protocols	Pricing	Weaknesses
Apidog	Markdown integration, rich elements, multi-language/version support	REST, SOAP, GraphQL, WebSocket	Free - $9/mo+	Limited integration, online only
SwaggerHub	Comprehensive API lifecycle management, easy standardization	REST	Free - $23/mo+	Focused on REST, complex for beginners
Postman	Full lifecycle support, collaboration, auto-generation of docs	REST, GraphQL, WebSocket, SOAP	Free - $12/mo+	Resource-intensive, limited customization
Redocly	Interactive docs, highly customizable	REST	Free - $12/mo+	Limited to OpenAPI, complex setup
Stoplight	Visual design, mock server, multi-protocol support	REST, GraphQL, WebSocket	Free - $99/mo+	Learning curve, smaller support community
Fern	Simplified setup, clean design	REST	Start from $400/mo	Limited protocol support
ReadMe	Interactive docs, code examples, customizable themes	REST, GraphQL	Free - $99/mo+	Costly for high usage, features locked behind paywall
GitBook	Modern design, Markdown support, real-time collaboration	General documentation platform	Free - $65/mo+	Not API-specific, additional integration setup required
Theneo	User-friendly, drag-and-drop, team collaboration	REST, GraphQL	Free - $120/mo+	Limited integration, lacks depth for complex APIs
apiDOC	Generates docs from comments, simple setup	REST	Free, open-source	Community-limited features, best for simpler projects

Best Practices for Developing Non-English APIs

Ismail Kamil — Thu, 26 Dec 2024 03:34:18 +0000

OpenAPI (Swagger) is the most popular API design tool, and Postman is the most widely used tool for API development and debugging. However, if your team's working language is NOT English, Swagger and Postman might not be the best choices.

I have tried a tool called Apidog, and from the perspectives of API design, API development and debugging, API mocking, and API documentation, it represents best practices for developing non-English APIs.

API Design

Swagger is the standard tool for API design. However, if the API is intended for non-English usage, Swagger can be quite challenging to read and write. Mastering Swagger itself presents a significant challenge.

This often leads many non-native English teams to abandon defining API specifications, instead opting to write code to achieve functionality. Consequently, the APIs developed may become difficult to call and collaborate on.

Apidog offers a great alternative for designing APIs in non-English languages.

Firstly, the API design in Apidog is entirely visual. You don't need to grasp the complicated API schema syntax in Swagger; you can design compliant APIs visually. You can easily reference schemas visually and use components to improve the efficiency and standardization of API design.

Secondly, Apidog thoughtfully provides a "title" attribute for non-English developers, which describes the property's name in your native language, corresponding with the English "name" attribute. (Currently supporting Japanese and Portuguese)

In addition to visualized design, Apidog automatically generates mock responses in the current language when creating response examples. (Supports all languages)

API Documentation

When you create an API spec in a non-English language, you can publish multilingual API documentation in Apidog. (Supports all languages)

API Development and Debugging

No matter what language your API spec is defined in, Apidog allows you to send requests in any language you need by generating the request body. (Supports all languages)

API Mocking

You can also generate corresponding Mock APIs based on your spec. (Supports all languages)

Overall, Apidog provides a comprehensive solution for non-English speaking developers, offering a seamless experience in designing, documenting, developing, and testing APIs. This tool empowers developers to focus on building functionality without being hindered by language barriers, effectively bridging the gap between different languages in software development.

🦴 Try Apidog 🐶

How to Build Your Frontend Apps 10x Faster!

Ismail Kamil — Thu, 05 Dec 2024 10:04:48 +0000

One of the biggest challenges in frontend development is the waiting game. When the API is not yet ready, the frontend team is often left with no choice but to hard-code the response data into the UI. This is a major bottleneck that hinders frontend development efficiency.

However, there is now an extremely efficient solution that allows you to mock any API data in just 1 min and provide it to the frontend team as an API.

The best part is that -- the mocked data is dynamic and almost indistinguishable from the real data.

Let's start.

Get the Required JSON.
Use Apidog to Create an Endpoint with your JSON.
Save and Get the Mock URL. Done!

Step 1: Get the Required JSON

When preparing to mock an API, obtaining the necessary JSON data is crucial. This JSON data represents the structure of the response your frontend application expects from the API. There are several methods for acquiring this JSON data:

Collaboration with Backend Team: Engage in discussions with your backend colleagues to get a precise understanding of the required data structure.
API Documentation Exploration: Review any existing API documentation that details the endpoints and typical response formats you can anticipate.
Existing Sample Data: If the application being developed is an enhancement or revision, older versions or similar projects may have existing sample data that can be used as a reference.
Manual JSON Construction: When data is unpredictable or not yet modeled, you might manually draft a sample JSON template based on expected fields and types.

Example JSON

Let’s consider the following example JSON structure for our mock API:

{
    "id": 93189357,
    "firstName": "Richard",
    "familyName": "Mertz",
    "email": "Joel_Bergstrom64@yahoo.com",
    "phone": "(588) 534-9295",
    "streetAddress": "789 Noel Fall",
    "city": "East Olgastead",
    "state": "Missouri",
    "zipcode": "04493",
    "gender": "female",
    "birthday": "2010-01-31",
    "bio": "assist advocate  🦝",
    "userAgent": "Mozilla/5.0 (compatible; MSIE 10.0; Windows NT 5.2; Trident/6.0)"
}

This is a fictional user JSON containing several common fields.

Now just copy it. If you've already such a JSON, this step will take you no more than 10 seconds.

Step 2: Use Apidog to Create an Endpoint with Your JSON

Apidog is an efficient tool for API development and mocking. First, download it from Apidog's website and register an account.

Once that's done, click "create a new endpoint" within your project.

The only field you must fill in is the endpoint path—use something like /user/{id} for accessing mock data.

Next, scroll to the Response section and click on the "Generate from JSON etc." button.

Paste your JSON data from Step 1 and click OK. Apidog will automatically generate the response schema and example based on your JSON.

Finally, click Save to save the endpoint.

This whole process, excluding download and registration, only takes about 30 seconds.

Step 3: Get the Mock URL

After saving your endpoint in Apidog, you'll find a mock module within the endpoint details. This module provides you with a mock URL. Simply click on the mock URL to copy it.

Next, paste this URL into your browser.

Congratulations! You now have a working mock API!

It's not just a static response; every time you refresh the page, you'll notice that the content changes, simulating the behavior of a real API. This dynamic response feature is invaluable for testing and developing frontend applications in a realistic environment without waiting for the backend to be ready.

How it works

Apidog operates as a robust platform for API development and mocking by intelligently interpreting your input JSON data. Here's a closer look at its functionality:

JSON Parsing and Data Schema Generation:

When you paste your JSON into Apidog, it parses the structure to create a corresponding data schema, establishing an API specification. This schema defines the expected format and type of data for each property in the JSON.

Mock Engine:

Apidog includes an integrated mock engine, effectively functioning as a lightweight mock server that runs locally on your PC. This engine uses your API specification to dynamically generate mock data.

For dynamic responses, Apidog utilizes the names of your JSON properties to apply appropriate mock functions from faker.js. These mock functions are responsible for producing realistic, random data. Each browser refresh triggers the generation of new mock data, giving the illusion of interacting with a real API.

Static Mock

If you prefer consistent outputs on every request, you have the option to switch the mock data from dynamic to static effortlessly:

During the JSON parsing process, Apidog saves the data as a response example.
To make use of this static option, go to Settings, navigate to Feature Settings, and access Mock Settings.
Change the default mock type to "Response example first." By doing this, the mock API will consistently return the saved response example, making your test data stable and predictable.

Custom Mock

If the automatically generated mock output for a specific property doesn't meet your requirements, Apidog allows you to customize this property's mock behavior easily.

Navigate to the Response Schema section for the relevant endpoint.
Locate the property whose mock needs adjustment. In the mock field of this property, choose a suitable function that aligns with your desired output.

Cloud Mock

The mock API we've discussed so far is hosted locally. However, if you need to share it with others or give access outside your local environment, Apidog provides a cloud mock feature.

To enable this feature, Go to Settings, navigate to Feature Settings, and access Mock Settings. Toggle on the Cloud Mock option.

Once enabled, your API will be accessible from the cloud. Simply copy the cloud mock URL provided and open it in a browser to access it. This feature makes it easy to share your mock API with team members, stakeholders, or testers who need to access it remotely.

For example, try visiting this cloud mock address to see it in action:
https://mock.apidog.com/m1/644296-613644-default/user/1

This is truly a comprehensive Mock API solution.

Apidog claims to be the REAL API Design-first Development Platform, and it can be used for Design, Debug, Test, Document, and Mock.

In practice, it is very user-friendly and effectively enhances the work efficiency of front-end, back-end, and testing teams.

You should give it a try as well.

🦴 Try Apidog 🐶

Apidog Official Website

2025 Review: 10 Top API Mock Tools

Ismail Kamil — Wed, 28 Dec 2022 06:37:44 +0000

What is API mock

API mock, or mock API, is a simulated version of an API that is used for testing and development purposes. It allows developers to test their applications or services without relying on a live API, and can be configured to return specific responses to incoming requests. This can be useful for testing the functionality of an application or service in different scenarios, and can help developers identify and troubleshoot any issues that may arise.

API mock tools typically provide a way to create a mock version of an API, configure it to return specific responses to incoming requests, and simulate different scenarios and behaviors. This can include simulating error responses, latency, and other types of responses that may be difficult or impossible to reproduce with a live API.

API mock tools are commonly used in the development and testing of applications and services that rely on APIs, as they can save time and effort compared to testing with a live API. They can also be useful for testing the robustness and reliability of an application or service, and can help developers ensure that their applications or services are functioning correctly.

When we need mock API

There are several situations in which mock APIs can be useful:

Testing: Mock APIs can be used to test the functionality of an application or service without relying on a live API. This can be useful for testing the robustness and reliability of an application or service, and can help developers identify and troubleshoot any issues that may arise.
Development: Mock APIs can be used to develop and test applications or services without having to wait for a live API to be available. This can be especially useful when the live API is not yet available, or when it is not feasible to use a live API for development or testing purposes.
Simulation: Mock APIs can be used to simulate different scenarios and behaviors that may be difficult or impossible to reproduce with a live API. This can include simulating error responses, latency, and other types of responses that may be difficult or impossible to reproduce with a live API.
Isolation: Mock APIs can be used to isolate an application or service under development from other systems, allowing developers to focus on the functionality of the application or service without being affected by external factors.

Overall, mock APIs can be useful in a variety of situations where it is necessary or desirable to test or develop an application or service without relying on a live API.

10 Top API Mock Tools

There are many different API mock tools on the market, each with its own set of features and capabilities. In this review, we will take a look at some of the top API mock tools, including their features, capabilities, and any relevant details such as supported platforms, pricing, and documentation.

Apidog

Apidog is a platform or tool that allows you to import an API definition and generate mock data for testing and development purposes. Its "Smart Mock" feature can generate mock data automatically based on the names of fields, allowing you to create realistic-looking mock data without having to manually specify the values for each field.

One of the benefits of using Apidog is that the mock data is generated automatically, and it changes each time the URL is requested. Apidog automatically generate user-friendly mock data based on your API specifications, and creates data that closely mimics real-world scenarios, covering a wide range of possible use cases.

Apidog is free to use, making it a good choice for developers who need a simple tool for testing and development purposes.

Postman

Postman is a popular tool for testing and interacting with APIs. Its "Mock Servers" feature allows you to set up a mock version of your API and configure it to return specific responses to incoming requests.

This can be useful for testing the functionality of your application or service without having to rely on a live API, and can help you identify and troubleshoot any issues that may arise. However, Postman may not provide as many tools for API design and mock server management as some other platforms, and may not be suitable for developers who need more advanced or customized mock server functionality.

Mocki

Mocki is an online tool for creating and hosting mock APIs. It allows you to set up a mock version of your API and configure it to return specific responses to incoming requests. mocki.io is relatively easy to use and has a wide range of features for mocking and simulating APIs, including support for importing and exporting mock configurations, generating random data for responses, and setting up conditional responses based on the contents of incoming requests.

One of the benefits of using Mocki is that it is a cloud-based tool, meaning that you can access and manage your mock APIs from anywhere with an internet connection. This can be especially useful for developers who need to collaborate with team members or clients remotely, as it allows everyone to access the mock APIs from their own devices.

Overall, Mocki can be a useful tool for testing and development purposes, particularly for developers who need a cloud-based solution for creating and managing mock APIs.

Mockoon

Mockoon is an open-source tool for creating and managing mock servers. It allows you to set up a mock version of your API and configure it to return specific responses to incoming requests.

Mockoon is relatively easy to use and has a wide range of features for mocking and simulating APIs, including support for importing and exporting mock configurations, generating random data for responses, and setting up conditional responses based on the contents of incoming requests.

Stoplight

Stoplight is a platform for designing, documenting, and testing APIs. Its "Mocks" feature allows you to create mock versions of your API for testing and development purposes. In addition to the mock feature, Stoplight also includes tools for API design, documentation, and testing, making it a comprehensive platform for API development.

However, Stoplight may be more complex to use and may require a subscription to access all of its features, making it less suitable for developers who are looking for a simple or free tool for testing and development purposes.

MockAPI

MockAPI is a tool for creating and hosting mock APIs. It allows you to set up a mock version of your API and configure it to return specific responses to incoming requests. mockAPI is relatively easy to use and has a wide range of features for mocking and simulating APIs, including support for importing and exporting mock configurations, generating random data for responses, and setting up conditional responses based on the contents of incoming requests.

One of the benefits of using MockAPI is that it is a cloud-based tool, meaning that you can access and manage your mock APIs from anywhere with an internet connection. This can be especially useful for developers who need to collaborate with team members or clients remotely, as it allows everyone to access the mock APIs from their own devices.

Overall, MockAPI can be a useful tool for testing and development purposes, particularly for developers who need a cloud-based solution for creating and managing mock APIs.

WireMock

WireMock is a Java-based library for stubbing and mocking web services. It is relatively simple to use and has a wide range of features for stubbing and mocking web services, including the ability to set up conditional responses based on incoming requests, simulate latency, and record and replay HTTP traffic.

This can be useful for testing the functionality of your application or service in different scenarios, and can help you identify and troubleshoot any issues that may arise. WireMock is open-source and available for free, making it a good choice for developers who need a simple tool for testing and development purposes. However, it may not be as easy to use for developers who are not familiar with Java, and may not provide as many features or customization options as some other tools.

Mountebank

Mountebank is a cross-platform tool for creating mock servers and stubbing HTTP APIs. It allows you to specify the behavior of your mock server using a simple configuration file, and can be used to simulate a variety of different scenarios, such as error responses and latency.

This can be useful for testing the robustness and reliability of your application or service, and can help you identify and troubleshoot any issues that may arise. Mountebank is open-source and available for free, making it a good choice for developers who need a flexible tool for simulating different scenarios and behaviors. However, it may not be as easy to use for developers who are not familiar with its configuration file format, and may not provide as many features or customization options as some other tools.

Apigee

Apigee is a comprehensive platform for designing, building, and testing APIs. It includes a feature called "API mocking," which allows you to create a mock version of your API for testing and development purposes. In addition to the mock feature, Apigee also includes a wide range of tools for API development, including support for API design, documentation, testing, and deployment.

However, Apigee may be more complex to use and requires a subscription to access all of its features, making it less suitable for developers who are looking for a simple or free tool for testing and development purposes.

Hoverfly

Hoverfly is an open-source tool for mocking and simulating APIs. It is relatively easy to use and has a wide range of features for mocking and simulating APIs, including support for importing and exporting mock configurations, generating random data for responses, and setting up conditional responses based on the contents of incoming requests.

This can be useful for testing the functionality of your application or service in different scenarios, and can help you identify and troubleshoot any issues that may arise.

Comparison

Tool	Features	Pricing	Ease of use	Platform
Apidog	Smart Mock feature for generating mock data automatically based on field names; free to use	Free	Easy	Web-based
Postman	Mock Servers feature for setting up a mock version of an API and configuring it to return specific responses to incoming requests; support for API design, documentation, and testing	Free	Easy	Windows, Mac, Linux
WireMock	Support for setting up conditional responses based on incoming requests, simulating latency, and recording and replaying HTTP traffic; open-source and free to use	Free	Moderate	Java
Mountebank	Support for specifying the behavior of a mock server using a configuration file; open-source and free to use	Free	Moderate	Windows, Mac, Linux
Apigee	API mocking feature for creating a mock version of an API; support for API design, documentation, testing, and deployment; subscription required for access to all features	Subscription	Moderate	Web-based
Hoverfly	Support for importing and exporting mock configurations, generating random data for responses, and setting up conditional responses based on incoming requests; open-source and free to use	Free	Moderate	Windows, Mac, Linux
Stoplight	Mocks feature for creating mock versions of an API; support for API design, documentation, and testing; subscription required for access to all features	Subscription	Moderate	Web-based
Mockoon	Support for importing and exporting mock configurations, generating random data for responses, and setting up conditional responses based on incoming requests; open-source and free to use	Free	Easy	Windows, Mac, Linux
Mocki	Support for importing and exporting mock configurations, generating random data for responses, and setting up conditional responses based on incoming requests; cloud-based	Free	Easy	Web-based
mockAPI	Support for importing and exporting mock configurations, generating random data for responses, and setting up conditional responses based on incoming requests; cloud-based	Free	Easy	Web-based

Mock REQUEST bodies automatically to accelerate API debugging

Ismail Kamil — Mon, 28 Nov 2022 10:18:59 +0000

When developing APIs, debugging is always a boring problem.

Postman can help send requests, but when the API body is complicated, constructing a JSON body would be difficult. Junit also works, but all requests must be constructed yourself in testing classes.

Complex bodies make many backends abandon unit tests and output an untested API to frontend developers and QA engineers.

The above case demonstrates that the code quality declines without a good tool.

And now, I found that a tool named Apidog can generate the request body automatically when debugging. The tool can construct a correct request JSON itself.

How to mock it

This approach works for API-first teams. APIs are designed before developing, so while debugging, you have an API specification.

1.Import the API specifications into Apidog. (How to?)
2.Open an API, and make sure the request has a JSON/XML body specification.

3.Switch to the "Run" tab, and click the "Generate Automatically" button.

OK. You've got a mock JSON according to the request specification!

And now click "send" to send the request like what we did in Postman, but more efficiently. Most features in Postman are also supported in Apidog.

Our team have used Apidog to debug APIs instead of Postman for weeks.

What's more

Notice the mock data. It was generated automatically according to the field name. A field named "city" are mocked with a city name, a field named photoUrl is mocked with a photo URL, and all mock data follows JSON schema specified in the API. Just like what I wrote in How to mock complex JSON.

And that's not the end.

Hover on the arrow beside "Generate Automatically", you'll see three menu items.

"Default value first" means the mock JSON would be filled by the default value specified in each field of the API first. "Example value first" means the mock JSON would be loaded by the example request JSON first. But what is "Refresh when sending request"?

It's just the literal meaning. Each time the request is sent, the body is generated again.

Interesting, isn't it?

Customize it

Until now, everything looks great.

But what if some of my fields are not expected to change? How can I make some fields fixed and some mocked?

Click the "Dynamic Value" button, and you'll find a new world.

All Faker.js syntaxes are supported, and you can select any of them directly. You can even select a function to mutate the mock value like md5, substr or base64 etc.
Then it will be inserted into the request body, just like this.

You can decide which field is fixed and which is mocked by Faker.js. When sent, all faker fields will change to the actual data below.

That's it. And it changes each time sending.

Apidog is a great tool that makes our team build APIs faster. I like it.

Download Apidog here.

How to Mock ONLINE APIs without setting up a server

Ismail Kamil — Tue, 22 Nov 2022 12:10:46 +0000

There are many approaches to mock JSON data and use it offline. But if you need some online data in your app, you'll have to run a mock server in your own cloud server.
That's not easy, especially for front-end developers.
But now, there is a fantastic way to start a mock server on the cloud, easily and free.

Why Mock APIs Online

In local development, offline mock data is enough for front-end developers. But there are some common scenarios where offline mock data is not good enough.

Scenario 1: Team shared mock data

Some data structure is complicated, maybe with many fields or following complex schemas. If several developers need the same mock API, the best solution is to build one online mock server that everyone can visit.
For teams, shared online mock data would accelerate their development a lot. Mock data can be defined only once.

Scenario 2: APIs under development

In many teams, APIs are not designed well at the beginning. An initial specification of how the API responses should look like is likely to change while it is developed for real. An offline mock data will soon be different from the real API responses.
So, online mock data following backend API specifications would be great.

How to mock it

In my previous articles, I introduced how to mock dynamic data on a local server rapidly in the tool Apidog.
And now I find that mocking on a cloud server is also easy and free!

Step 1: Import API definitions

API documentation is necessary. OpenAPI (Swagger) is best, and any other format is OK, too.

Create a new project in Apidog.

Go to "Settings"-"Import", and drag your API file in.

More than ten formats of API documentation are supported. Click "Next" and your API will be imported.

Step 2: Turn on the cloud mock server

Go to "Settings"-"Feature Settings"-"Mock Settings", and turn on the "Cloud Mock" switch.
Cloud mock can be accessed open, or you can set a token for it.

Step 3: Get the mock URL

Click an API in Apidog. You'll see an API definition page, in which there is a section named "Mock". Copy the URL in the "Cloud Mock" part which starts with "mock.apidog.com".

Paste it into your browser.

OK, it's done! You'll see a mocking JSON!

A "city" field is filled by a city name, an "id" field is filled by an integer, and "status" is a enum field.

Now you can use the API data in your app, and anyone in the team can access this URL to get data.

Still, you don't need to write any scripts. Data in all fields are generated automatically.

And when you click "reload" in the browser, the data will refresh.

APIs under development

This approach solved the team-shared mock data scenario. But if the API is still under development, how can the other developers get the latest mock data?

The solution is also in Apidog. Apidog is an all-in-one API developing toolkit, so the backend developers can use it to debug the APIs like in Postman and specify APIs like in Stoplight. Apidog can synchronize Swagger automatically so API specifications can be kept the latest. When API specifications change, the online mock data changes synchronizing.

It's a perfect API developing toolkit for teamwork.

You can register or download Apidog here.

How to Mock complex APIs in TWO minutes

Ismail Kamil — Mon, 21 Nov 2022 12:15:34 +0000

Many developers love the solution I wrote in How to Mock an API in ONE minute. In the article, I introduced an approach to mock an API rapidly.

But what I wrote is only a tiny part of the tool. After a period of exploring, I found more valuable features to mock complex data faster.

Complex JSON

My last article introduced how to import a Swagger API into Apidog to mock some JSON data. Then you can have your mock data directly without any scripts.

But some fields are complicated; you can't mock them without any settings.

For example, an enum field has several optional values. It usually appears in status fields.

Or an array with a fixed length. It's often used in a table where each row has several attributes, and each page has 20 or 50 rows.

Or, an object refers to a schema. OpenAPI specification allows an API to refer to a schema as an object or part of an object.

Luckily, now we can quickly mock all these complex JSON in two minutes in Apidog.

Let's Mock it

There are three steps to mock the API.

Import API definitions.
Set specific fields.
Get the mock URL.

So easy. Let's mock it!

Step 1 is the same as How to Mock an API in ONE minute. You just need an OpenAPI JSON or YAML and import it into Apidog.

Step 2. Set specific fields.

Enum values

In this sample API, the 'status' field has three optional values: available, pending, and sold. So I hope this field in my mocking data has only one of these values too.

Click 'More' in the 'status' field. You'll see an 'Enum' switch. Turn it on, and you'll be able to add enum values. After that, data of this field will be mocked according to the settings.

Arrays with fixed length

PhotoUrls is an array field. I need it to have a fixed five items.

Click 'More' in the 'PhotoUrls' field. You'll see an 'Element Limit' setting. Set the minItems 5 and maxItems 5.

Object refers to a schema

Apidog support schemas in OpenAPI specification. So you just need to select a Schema for an object, and Apidog will mock the object according to the schema.

For example, the 'Category' field.

Step 3. Get the mock URL.

Click ‘Save', and switch to the 'API' tab. Copy the URL in the "Local Mock" part which starts with "127.0.0.1".

Paste the URL into the browser.

That's it.

Notice these fields: photoURLs with fixed item quantity(5), while URLs are mocked automatically with available image URLs; status with enum values(sold, pending, or available), and category refers to a schema. The other fields, like city and createdAt are mocked automatically.

And if you reload the URL, the mock data refreshes.

JSON Schema

OpenAPI 3.0 data types are based on JSON Schema, which describes the data structure of APIs.

Apidog is compatible with OpenAPI. Length range, format, and pattern(regular expression) of strings, min and max value of integers, readonly/writeonly; all attributes in JSON Schema are supported.

Not only JSON but XML is also supported to mock. You can even set the tag names and prefixes of XML data.

Based on JSON Schema, any complex mock data can be generated easily with a few mouse clicks. Still, you don't need to write any scripts.

Just enjoy it.

Download Apidog here, and wait for my next post to see more powerful mock features.

How to Mock an API in ONE minute

Ismail Kamil — Fri, 18 Nov 2022 06:45:23 +0000

Front-end developers usually meet this problem. The API is designed, but it's not been implemented yet. I need to make some fake data for my interface, which means I have to set up a mock server and add some response examples. If there are no response examples in the API documentation, I must make up some response data myself.

Each time I do this, I think it's not what a front-end developer should do.

There should be a better way to accomplish this.

I tried many tools. I used postman as a mock server, but all response data must be added manually. I tried faker.js, but I have to write mocking code for every field.

In my expectation, an excellent mocking server should generate data itself. Developers should pay attention to real essential things.

Great news: Now, you can mock an API in only one minute. And you don't need to write any scripts.

Why mocking

Mocking is a good choice if you're on one of the following occasions.

The API is designed but not developed. This usually happens in agile teams.
Restricted or paid APIs. For example, bank APIs. You cannot get real data before development completes. So you need mock data.
Offline environment or intranet. Mock data allows you to work on a local machine.

Let‘s Mock it

There are two steps to mock the API.

Import API definitions.
Get the mock URL.

So easy. Let's mock it!

Step 1 - Import API definitions

API documentation is necessary. OpenAPI (Swagger) is best, and any other format is OK, too.

Assume you have a YAML or JSON file. We’ll import it into this tool: Apidog. If you don’t have an API yet, you can also create it in Apidog.

1.Create a new project in Apidog.

2.Go to "Settings"-"Import", and drag your API file in.

More than ten formats of API documentation are supported. Click "Next" and your API will be imported.

Now you'll see the APIs in Apidog.

Step 2 - Get the mock URL

1.Click an API in Apidog. You'll see an API definition page, in which there is a Section named "Mock".

2.Click the URL in the "Local Mock" part which starts with "127.0.0.1" to copy it.

3.Paste it into your browser.

OK, it's done! You'll see a mocking JSON!

A "city" field is filled by a city name, an "id" field is filled by an integer, and "createdAt" is filled by a date-time.

Now you can use the API data in your App.

And you don't need to write any scripts! Data in all fields are generated automatically.

Moreover, if you click "reload" in the browser, the data will refresh!

Amazing.

How it works

The first time I found this feature, I was quite surprised. Why can Apidog generate this? I didn't set anything!

Later I found this.

There is a batch of built-in mocking rules in Apidog, as above. If your field name in the response definition matches one of them, the field data will be mocked automatically.

And Apidog starts a mock server in your local machine automatically. So you don't need to do anything in the server layer.

What if you don't like the data it mocks automatically? That's also easy.

You can directly fill the mock value of the field with Faker.js like this.

All Faker.js grammar is supported so that you can select them easily.

And if some field has a fixed value, you can also fill the "mock" with the specified value.

Alright, all done.

I hope you mock happily with Apidog.

It's really a good tool. And I found it's not only good for mocking but for everything in API development.

Download Apidog here.

DEV Community: Ismail Kamil

Top 10 API Documentation Tools 2025 (with examples)

1. Apidog

Features

Example Documentation

Supported Protocols

Pricing

Weaknesses

2. SwaggerHub

Features

Example Documentation

Supported Protocols

Pricing

Weaknesses

3. Postman

Features

Example Documentation

Supported Protocols

Pricing

Weaknesses

4. Redocly

Features

Example Documentation

Supported Protocols

Pricing

Weaknesses

5. Stoplight

Features

Example Documentation

Supported Protocols

Pricing

Weaknesses

6. Fern

Features

Example Documentation

Supported Protocols

Pricing

Weaknesses

7. ReadMe

Features

Example Documentation

Supported Protocols

Pricing

Weaknesses

8. GitBook

Features

Example Documentation

Supported Protocols

Pricing

Weaknesses

9. Theneo

Features

Example Documentation

Supported Protocols

Pricing

Weaknesses

10. apiDOC

Features

Example Documentation

Supported Protocols

Pricing

Weaknesses

Best Practices for Developing Non-English APIs

API Design

API Documentation

API Development and Debugging

API Mocking

How to Build Your Frontend Apps 10x Faster!

Step 1: Get the Required JSON

Example JSON

Step 2: Use Apidog to Create an Endpoint with Your JSON

Step 3: Get the Mock URL

How it works

Static Mock

Custom Mock

Cloud Mock

2025 Review: 10 Top API Mock Tools

What is API mock

When we need mock API

10 Top API Mock Tools