JSON (JavaScript Object Notation) is a lightweight data-interchange format that has become the standard for network automation and programmability. For the CCNA 200-301 exam, objective 6.4 requires you to understand JSON syntax, its use in REST API responses, and how to parse it for network configuration and monitoring. Real network engineers use JSON daily when interacting with Cisco DNA Center, Meraki dashboards, or any SDN controller. Mastering JSON is not just about passing the exam—it's about being able to automate repetitive tasks and integrate networks with modern DevOps workflows.
Jump to a section
Imagine you work at a large shipping port. Every day, thousands of containers arrive on ships, each filled with various goods. To manage this chaos efficiently, you don't open every container and inspect its contents manually—that would take forever. Instead, you use a standardized shipping manifest form. Each manifest is a piece of paper that lists key information in a predictable structure: the container ID, origin, destination, weight, and a list of items inside. The manifest is written in a simple, human-readable format: it uses curly braces { } to group all information for one container, and each piece of data is labeled with a key (like "containerID") followed by a colon and the value. If an item has sub-items, like a list of packages, it uses square brackets [ ] to enclose that list. This structure is exactly how JSON works. In networking, when a controller asks a device for its configuration, the device sends back a JSON document—like a manifest—that organizes all the data into key-value pairs. The curly braces { } represent the entire device or a specific object, and the square brackets [ ] represent arrays of similar items (like a list of interfaces). Just as a port worker can quickly look at a manifest to find the weight of container #42 without searching through the entire pile, a network script can parse JSON to extract the IP address of interface GigabitEthernet0/1 without reading the entire configuration. JSON's rigid structure—every key must be a string in double quotes, values can be strings, numbers, booleans, arrays, or nested objects—ensures that both humans and machines can read and write it without ambiguity. This standardization is why JSON is the lingua franca for REST APIs in network automation.
What is JSON?
JSON (JavaScript Object Notation) is a text-based data format derived from JavaScript object literal syntax, but it is language-independent. It is used to transmit data between a server and a client, or between network devices and controllers. For CCNA, you must be able to read and write JSON that represents network configurations, such as interface settings, routing table entries, or device inventory.
JSON Syntax Rules
JSON is built on two structures:
A collection of name/value pairs (often called an object). In various languages, this is realized as an object, record, struct, dictionary, hash table, keyed list, or associative array.
An ordered list of values (an array). In most languages, this is realized as an array, vector, list, or sequence.
Key syntax rules:
Data is in key/value pairs separated by commas.
Curly braces {} hold objects.
Square brackets [] hold arrays.
Keys must be strings enclosed in double quotes.
Values can be: string (double quotes), number (integer or floating point), boolean (true/false), null, object (nested {}), or array (nested []).
No trailing commas allowed.
JSON is whitespace-insensitive, but formatting (indentation) improves readability.
JSON Data Types in Detail
String: A sequence of zero or more Unicode characters, wrapped in double quotes. Example: "interface-name": "GigabitEthernet0/1"
Number: An integer or floating point. Example: "vlan-id": 100 or "bandwidth": 1.544
Boolean: true or false (lowercase). Example: "enabled": true
Null: null (lowercase) indicates no value. Example: "description": null
Object: An unordered collection of key/value pairs. Example: {"interface": {"name": "GigabitEthernet0/1", "ip": "10.1.1.1"}}
Array: An ordered list of values, each of any type. Example: "vlans": [10, 20, 30]
How JSON is Used in Network Automation
When a network engineer sends a REST API request to a Cisco DNA Center or Meraki dashboard to retrieve device configurations, the response is typically in JSON format. For example, a GET request to /api/v1/device might return:
{
"response": [
{
"hostname": "Router1",
"managementIpAddress": "192.168.1.1",
"platformId": "ISR4331",
"softwareVersion": "16.9.3"
},
{
"hostname": "Switch1",
"managementIpAddress": "192.168.1.2",
"platformId": "C9300-24P",
"softwareVersion": "16.12.2"
}
]
}To parse this, a Python script using the json module can access response[0]['hostname'] to get "Router1".
JSON vs. Other Data Formats
XML: Verbose, uses tags. JSON is more compact and faster to parse.
YAML: Uses indentation, more human-readable. JSON is stricter and easier for machines to parse.
For CCNA, you need to know JSON specifically for REST API interactions.
IOS CLI and JSON
Cisco IOS XE devices support output in JSON format via the | json pipe. For example:
Router# show ip interface brief | jsonOutput:
{
"interface": [
{
"name": "GigabitEthernet0/0",
"ip_address": "192.168.1.1",
"status": "up",
"protocol": "up"
},
{
"name": "GigabitEthernet0/1",
"ip_address": "unassigned",
"status": "administratively down",
"protocol": "down"
}
]
}This allows automation scripts to consume structured data directly from the CLI.
Interacting with REST APIs
A REST API request typically includes:
HTTP method (GET, POST, PUT, DELETE)
URL endpoint
Headers (Content-Type: application/json)
Body (in JSON format for POST/PUT)
Example POST to create a VLAN:
{
"vlanId": 100,
"name": "Engineering"
}The server responds with JSON containing the created resource.
Common JSON Structures in Networking
Device inventory: Array of device objects
Interface configuration: Nested object with properties like IP, subnet mask, status
Routing table: Array of route objects with destination, next-hop, metric
ACL rules: Array of rule objects with sequence, action, protocol
Validation and Formatting
Always validate JSON using tools like jsonlint.com or jq command-line tool. Common mistakes:
Missing commas between key/value pairs
Extra trailing comma
Single quotes instead of double quotes for keys
Mismatched brackets or braces
Exam Relevance
CCNA 200-301 objective 6.4 (Automation) expects you to:
Identify JSON syntax errors
Extract data from a JSON document
Convert between JSON and other formats (conceptually)
Understand how JSON is used in REST API payloads
Recognize JSON in show command output with | json
Identify JSON Syntax Errors
Given a JSON snippet, check for common errors: keys must be double-quoted; strings must be double-quoted; no trailing commas; objects and arrays must be properly closed. Example error: `{name: "Router1"}` is invalid because `name` lacks quotes. Correct: `{"name": "Router1"}`. Also note that `true`, `false`, `null` are lowercase. On the exam, you might be asked to choose the valid JSON from multiple options.
Parse JSON to Extract Data
Given a JSON document (e.g., from a REST API response), you must be able to locate specific values. For example, from `{"interfaces": [{"name": "Gig0/0", "ip": "10.1.1.1"}]}`, extracting `interfaces[0]['ip']` yields `"10.1.1.1"`. Practice navigating nested objects and arrays. The exam may ask: 'What is the IP address of the second interface?' requiring you to access index 1.
Construct JSON for API Payload
When sending a POST request to configure a device, you need to format the body as JSON. For example, to create a VLAN, the payload might be: `{"vlanId": 100, "name": "Voice"}`. Ensure correct syntax: keys in double quotes, comma between pairs, no trailing comma. The exam might present a scenario and ask you to select the correct JSON payload.
Use '| json' in IOS CLI
On Cisco IOS XE devices, append `| json` to a show command to get JSON output. Example: `show running-config | section interface | json`. This returns the interface configuration as JSON. The exam may show this output and ask you to interpret it. Note that not all commands support `| json`; it works primarily on structured output commands like `show ip interface brief`, `show vlan brief`, etc.
Convert Between JSON and Other Formats
Conceptually, you should understand how JSON differs from XML and YAML. For example, the XML `<device><hostname>R1</hostname></device>` is equivalent to JSON `{"device": {"hostname": "R1"}}`. YAML uses indentation: `device: hostname: R1`. The exam may ask you to identify the JSON equivalent of an XML snippet. Focus on the structure: JSON uses braces and brackets, XML uses tags, YAML uses indentation.
Interpret JSON from REST API Response
When a REST API returns JSON, you need to read the status code and body. A successful GET returns 200 OK with JSON body. For example, a response might contain `{"response": [{"hostname": "R1", "status": "up"}]}`. The exam might ask: 'How many devices are returned?' requiring you to count array elements. Or: 'What is the status of the first device?' requiring access to `response[0].status`.
In production networks, JSON is used extensively for automation and integration. Here are three common scenarios:
1. Device Onboarding with Cisco DNA Center When a new switch is added to a network, the network engineer uses DNA Center's REST API to provision it. The engineer sends a POST request with a JSON payload containing the device's serial number, management IP, and site location. DNA Center responds with a JSON object confirming the device is added. This replaces manual CLI configuration, reducing errors and saving time. At scale, a script can onboard hundreds of devices by iterating over a JSON array of device details. Misconfigurations often occur when the JSON is malformed—e.g., missing quotes or incorrect key names—causing the API to reject the request with a 400 Bad Request error.
2. Monitoring with Meraki Dashboard API
Meraki's cloud-managed networks expose a JSON-based API for monitoring. For example, to get the status of all access points in a network, a GET request to /api/v0/networks/{networkId}/devices returns a JSON array. A script can parse this to check if any APs are offline and trigger alerts. This is critical for large campuses with hundreds of APs. Performance consideration: API rate limits (e.g., 5 requests per second) require batching. If the JSON response is too large, pagination is used—each page returns a subset with a nextPageToken.
3. Configuration Backup Automation
Network engineers write scripts that SSH into devices and run show running-config | json to retrieve the configuration as JSON. They then store these JSON files in a version control system like Git. This allows diffing between configuration versions. A common pitfall: some older IOS versions do not support | json for all commands, causing the script to fail. The engineer must handle exceptions. Also, the JSON output may contain sensitive data like passwords (though they are hashed), so access control is important.
When JSON is misconfigured in API payloads, the most common issue is incorrect key names. For example, using "ip_address" when the API expects "ipAddress" leads to silent failures or unexpected behavior. Always refer to the API documentation. Another issue is data type mismatch—sending a string for an integer field causes validation errors. Proper testing with tools like Postman can catch these mistakes before production deployment.
The CCNA 200-301 exam tests JSON under objective 6.4: 'Automation'. You will typically see 1-2 questions on JSON syntax or data extraction. Here's exactly what you need to know:
What is tested: - Valid JSON syntax (keys double-quoted, no trailing commas, correct data types) - Extracting values from a given JSON object (e.g., what is the value of 'ip' in the second interface?) - Identifying the correct JSON payload for a REST API request - Understanding that JSON is used for data interchange between network devices and controllers
Common wrong answers and why:
1. Choosing a JSON with single-quoted keys – Candidates often think single quotes are acceptable because they are used in Python dictionaries. In JSON, keys must be double-quoted. The exam will have distractors with single quotes.
2. Selecting JSON with trailing comma – Many languages allow trailing commas, but JSON does not. A trailing comma after the last element in an object or array is invalid.
3. Confusing JSON with JavaScript object literal – JSON is stricter. For example, JavaScript allows keys without quotes; JSON does not. Also, undefined is not a JSON value; only null is allowed.
4. Misreading nested arrays – Candidates may incorrectly assume interfaces[0] is the first interface, but if the array is nested deeper, they might miss the correct path.
Specific values to remember:
- JSON data types: string, number, boolean, null, object, array.
- Boolean values are true and false (lowercase).
- Null is null (lowercase).
- The pipe command is | json (space before pipe is optional but recommended).
Decision rule for scenario questions: If asked to choose a valid JSON payload for an API call, first check that all keys are double-quoted. Then check for trailing commas. Then verify that strings are double-quoted. Finally, ensure that arrays use square brackets and objects use curly braces. If any of these are violated, that option is invalid.
Calculation traps: None directly, but you may need to count array indices (starting at 0). For example, the third element is at index 2.
JSON syntax requires double quotes for all keys and string values.
JSON supports six data types: string, number, boolean, null, object, array.
Trailing commas are not allowed in JSON.
Cisco IOS XE supports `| json` to output structured data as JSON.
REST API requests often use JSON for both request payloads and responses.
JSON is more compact than XML and easier for machines to parse.
In JSON, boolean values are lowercase `true` and `false`.
JSON objects are enclosed in curly braces {}; arrays in square brackets [].
These come up on the exam all the time. Here's how to tell them apart.
JSON
Uses curly braces {} and square brackets []
Keys must be double-quoted strings
More compact and less verbose
Faster to parse due to simpler structure
No support for namespaces or attributes
XML
Uses angle brackets <tag> and </tag>
Tag names are not quoted
More verbose with opening and closing tags
Slower to parse, requires more memory
Supports namespaces and attributes
Mistake
Single quotes are acceptable for JSON keys and string values.
Correct
JSON strictly requires double quotes for all keys and string values. Single quotes are not valid.
Candidates often come from Python where single-quoted strings are common, but JSON is language-independent and follows a stricter specification.
Mistake
JSON can contain comments like // or /* */.
Correct
JSON does not support comments. Any attempt to include comments results in invalid JSON.
Some configuration files like YAML allow comments, so candidates assume JSON does too.
Mistake
The `| json` pipe works on any Cisco IOS command.
Correct
`| json` only works on commands that output structured data, such as `show ip interface brief`, `show vlan brief`, etc. It does not work on unstructured output like `show running-config` (though `show running-config | section` may work).
Candidates may think it is universally supported, but it depends on the command's internal data model.
Mistake
JSON arrays can have a trailing comma after the last element.
Correct
JSON does not allow trailing commas. The last element in an array or object must not be followed by a comma.
Many programming languages allow trailing commas for convenience, but JSON's specification (RFC 7159) explicitly forbids them.
Reveal each answer, then mark whether you got it right. Score 60%+ to unlock the next chapter.
JSON (JavaScript Object Notation) is a lightweight data-interchange format that is easy for humans to read and write and easy for machines to parse and generate. In networking, it is used to exchange data between network devices and controllers (e.g., Cisco DNA Center, Meraki) via REST APIs. JSON's structure of key-value pairs and arrays maps well to network configuration objects like interfaces, VLANs, and routes. For the CCNA exam, you need to understand JSON syntax and how to extract data from JSON responses.
You can append `| json` to certain show commands on Cisco IOS XE devices. For example: `show ip interface brief | json`. This returns the output in JSON format. Not all commands support this; it works best with commands that have structured output. The JSON output can be used by automation scripts to parse configuration or status data. Exam tip: Remember the pipe syntax and that it is case-sensitive (`| json`, not `| JSON`).
Common mistakes include: using single quotes instead of double quotes for keys and strings; trailing commas after the last element in an object or array; missing commas between key-value pairs; mismatched brackets or braces; using `undefined` instead of `null`; and using comments (JSON does not support comments). Always validate your JSON with a linter before using it in an API call.
Use dot notation or bracket notation to traverse the hierarchy. For example, given `{"device": {"interfaces": [{"name": "Gi0/0"}]}}`, to get the name of the first interface, you would use `device.interfaces[0].name` (in JavaScript) or `device['interfaces'][0]['name']` (in Python). The exam may ask you to identify the value at a specific path.
JSON uses curly braces and brackets, while YAML uses indentation (spaces) to denote structure. JSON is more verbose but stricter, making it easier for machines to parse. YAML is more human-readable but can be ambiguous with indentation. Both are used in network automation; JSON is more common for REST APIs, while YAML is often used for configuration files (e.g., Ansible playbooks). For CCNA, focus on JSON.
No, JSON does not support comments. If you need to add notes, you must use a separate field (e.g., `"description": "This is a comment"`). Some implementations may strip comments before parsing, but they are not part of the JSON specification. Exam tip: An option with comments is invalid JSON.
There is no direct conversion because the structures differ. XML has attributes and namespaces, which JSON does not. However, many libraries provide conversion functions that map XML elements to JSON objects. For example, `<device><hostname>R1</hostname></device>` becomes `{"device": {"hostname": "R1"}}`. The exam may test your ability to conceptually map between the two formats.
You've just covered JSON Data Format for Networking — now see how well it sticks with free CCNA 200-301 practice questions. Full explanations included, no account needed.
Done with this chapter?