How to write comments inside a JSON document?

Have you ever wondered how to add comments to your JSON documents? What are the good practices associated with it? Why are the comments not allowed in a JSON file by standard definition? These are questions that many enthusiasts and developers of JSON documents often encounter.

According to the JSON standard by Crockford, JSON does not support comments. This often has been argued by developers to lack a needed key feature to add context, explanations, or TODOs – critical elements in a developer’s workflow (Source: Humphrey, C., 2021; Source:, 2021). However, there is a method to incorporate comments into JSON documents, by considering JSON files as a subset of JavaScript. With this approach in mind, the requirement to include comments in JSON documents becomes a feasible task to accomplish.

In this article, you will learn about the various practices which are not standard but are implemented to achieve the ability to comment on JSON files. While commenting is not a feature provided by JSON, developers routing the workaround have ways to manage their JSON files effectively and proficiently.

A detailed guide will illustrate how you can manually add comments to make your JSON documents more meaningful and easy to understand. This detailed elucidation would also bring into light the various ways how developers have cracked a solution to this problem around the globe.

How to write comments inside a JSON document?

Definitions and Meanings in JSON Documents

JSON, standing for JavaScript Object Notation, is a text format often used to store and transport data. Unlike programming languages, JSON doesn’t support comments directly. However, people often need to add comments for better understanding or effective data usage. Comments in JSON are similar to notes that give additional explanations about a certain section, without altering the actual data. In other coding languages, comments start with a ‘/*’ and end with a ‘*/’, but in JSON, this isn’t possible. Instead, developers use external tools and software that allow JSON file annotation. Please note that these annotations are usually removed when data is transmitted, as JSON data doesn’t inherently recognize comments.

Unveiling the Mystery: Incorporating Comments into a JSON Document

The Challenge with JSON

Ironically, while JSON (JavaScript Object Notation) is a popular data-interchange format due to its simplicity and readability, it ironically does not support comments directly. This creates complications when programmers need to include brief explanations or highlights about specific portions of the data to increase readability for humans. You can argue that metadata within the data architecture is just as important as the data itself. However, JSON’s lack of an official “commenting” methodology can make it less intuitive for annotating or documenting why specific data structures were employed or what certain values might represent.

Common Workarounds for JSON Commenting

There are a few commonly accepted workarounds that developers employ to incorporate comments into a JSON file. The first one includes using an application that supports JSONC, an extension of JSON that accepts C-style comments, either inline using two slashes (//), or multiline using slash-asterisk (/* */). However, if the JSON files are going to be used in an environment that only accepts true JSON, these comments must be removed.

Another method is to treat comments as additional string data in your JSON file. This involves including them as field-value pairs in your JSON objects. For instance, `”Comment”: “This contains configuration settings”` is a legitimate JSON and serves as a comment. However, care must be taken since these comments will be parsed and interpreted as a regular data by any JSON parser.

  • {“Comment”: “This is a great workaround”, “Config_Settings”: {“width”: “200”, “height”: “400”}}
  • {“Comment”: “Remember to remove before deploying”, “_Config_Settings”: {“width”: “250”, “height”: “450”}}
  • {“Comment”: “Test before use”, “__Config_Settings”: {“width”: “300”, “height”: “500”}}

There are third-party languages designed to extend JSON capabilities, like JSON5 and HJSON, offering not only comments but other features as well. However, using them requires adding dependencies to your projects which could pose potential risks.

It should be noted that the absence of a commenting feature in JSON is intentional. JSON has been designed to be a data exchange format, and the metadata content such as commentary is considered both superfluous and detrimental to performance. It means that the correct approach would be removing the comments prior to using the JSON data in a live environment. But for testing, debugging, and configuration files, comments can be extremely valuable.

Commenting in JSON is still a debated topic in software development, with many developers hoping for a future version of JSON that will officially support comments. Until that time, developers will have to rely on these workarounds to include comments in their JSON files.

Untangling the JSON Paradox: Commenting Without a Designated Syntax

The Puzzle: Can You Articulate Codes Without A Dedicated Language?

Is it feasible to annotate or illustrate codes in a language that does not have a provision for commentary? Incredibly, JavaScript Object Notation (JSON) is a prominent format for data intercommunication, widely utilized due to its simplicity and compatibility with many programming dialects. However, an aspect of JSON that often puzzles users is its absence of a formal syntax for accommodating comments. Many developers habitually turn to comments to explain and understand their code better, making the place of comments in JSON a significant topic of discourse.

Navigating the Nuance: The Crux Of The Matter

The primary challenge here lies in the specification of JSON, which inherently does not support comments. Thus, while working on coding projects involving JSON, developers may struggle with the dilemma of leaving helpful hints or detailed explanations within their JSON documents. This issue makes the maintenance and managing of complex projects highly troublesome. Additionally, the strict standardization of JSON leads to a multitude of parsers rejecting the addition of comments, further exacerbating the issue.

A New Perspective: Implementing Best Practices

In spite of these constraints, there are methods that developers can adopt to bypass this problem. First, encapsulating the data along with the comments in a string is an effective solution. Here, developers can use a JSON object with two properties, the actual data, and the comment about the data. Second, the usage of ‘dummy’ keys is another intuitive methodology, where developers can insert keys that signify comments relevant to nearby code lines. Yet, these practices require careful consideration due to its deviation from the JSON schema’s objective of considering only data and not metadata. They also underline the delicate balance developers must maintain in accomplishing clarity without compromising the purity and functionality of their codes.

Breaking Boundaries: Innovative Ways to Embed Comments in JSON Documents

Is JSON Commenting Even Possible?

Does JSON format offer a direct way for embedding comments? JSON, JavaScript Object Notation, in its true essence, is data format that is primarily formulated for the transfer of data over the web. JSON is parsed and generated by browsers or rather by JavaScript engines, which don’t carry support for commenting. This is where the fundamental issue arises – the lack of direct provision for commenting within a JSON document. However, as we dive deeper, we realize that this lack of provision does not mean it is impossible. The need for commenting in JSON usually emerges when JSON data increases in complexity and developers wish to add annotations or descriptions to make the data more understandable for future reference.

Understanding the Complication with Commenting in JSON

Delving into the core problems, JSON lacks the basic ‘comment’ syntax available in most programming languages, mainly due to Douglas Crockford’s (the originator of JSON) intentional decision to keep JSON data format minimal and clutter-free. He reasoned that comments weren’t data and thus should not be integrated. This principle might make sense when JSON is used for what it’s primarily intended for – data transmission between server and web application. In such cases, comments may be viewed as irrelevant or incremental to bandwidth and processing time. However, with the ubiquitous use of JSON in various aspects, such as configuration files, the absence of commenting feature introduces complexity and creates a hurdle for developers in tracking and annotating their data.

Practical Tactics for Comments Embedding in JSON

Although JSON does not support commenting per se, there are certain innovative practices that developers have devised to annotate their JSON files. One of these involves using a key-value pair where the key could be ‘_comment’ or ‘remark’ etc. and the value could hold the actual comment. This method might solve the purpose but adds to the actual data and can add confusion between actual data and comment-data. Another commonly used practice is to stringify JSON in JavaScript and place comments in the JavaScript file, preserving original JSON schema. This practice, however, requires the JSON to be embedded within a JS file which might not always be suitable or convenient. Lastly, several tools are available, like ‘JSON5’, ‘JSONC’ etc., that are extensions to the standard JSON and do support comments, but they require the use of a specific parser and are not universally accepted. Despite these practices being a workaround, the fact remains that JSON remains comment-less at its core. This not only poses challenges but also opens avenues for innovation and augmentations, as seen with JSON’s extensions.


Can we truly have the luxury of making our JSON documents more comprehensible and easier to maintain without having the privilege of inserting comments? This dilemma seems intriguing and may lead us to reevaluate the standard practices we follow when dealing with JSON. As we discovered in this write up, it’s technically not allowed to write comments in a JSON document. However, we learned workarounds like using external documenting tools or manipulating the data items to mimic comments for our understanding.

We encourage you to follow this space for more enlightening discussions on JSON and many more programming paradigms. Whatever the limitation might be, programmers always have their ways to work around and beating the odds. We promise to bring more such tips and hacks to your plate that’d enrich your programming journey. Await our new releases that will explore various other topics that you have been wondering about.

In conclusion, though JSON does not natively support comments, we do not need to fret over this. As we have discovered, there are several ways we can circumvent this challenge. It requires us to think out of the box and put on our experimental hats. Remember that the constraints should not hinder our journey to create amazing digital solutions. Rather, they should ignite curiosity and invite innovations. Let’s conquer these challenges and continue to create!


1. Can you directly write comments inside a JSON file?
No, JSON format doesn’t support comments directly. Unlike some other programming languages, JSON is designed to strictly hold data therefore, doesn’t allow the inclusion of comments.

2. How can I annotate or add informational text to my JSON data?
You can add informational text via string properties within JSON objects. However, this workaround assumes that your program’s logic will correctly ignore or handle these informational properties.

3. Is it possible to add comments in JSON like JavaScript?
Unfortunately, no. Even though JSON is a subset of JavaScript, it doesn’t allow the use of JavaScript’s /*…*/ or // comment syntax. This is to keep JSON clean and data-focused.

4. Are there any tools or methods we can use to include comments in JSON?
Yes, some workaround methods or tools can be used to incorporate comments in JSON. One such method is using a pre-processing tool that supports comments, but removes them when the JSON is parsed or deployed.

5. What are the potential issues of adding pseudo-comments in JSON?
Pseudo-comments could conflict with real data. To avoid this, use unique keys for your pseudo-comments. Also, remember that parsers, servers, or other tools might not handle these pseudo-comments appropriately.