# JSON Data Format for Networking

> Chapter 102 of the Courseiva CCNA curriculum — https://courseiva.com/learn/ccna/json-networking

**Official objective:** 6.4 — CCNA 200-301 v2.0 Objective 5.3

## Introduction

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.

## The Shipping Manifest Analogy

A large shipping port is a chaotic intersection of container shipments, and you are its overseer. 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.

## Core explanation

### 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:
```json
{
  "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 | json
```
Output:
```json
{
  "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:
```json
{
  "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`

## Real-world context

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.

## Exam focus

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.

## Step by step

1. **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.
2. **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.
3. **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.
4. **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.
5. **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.
6. **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`.

## Comparisons

### JSON vs XML

**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

## Common misconceptions

- **Misconception:** Single quotes are acceptable for JSON keys and string values. **Reality:** 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.)
- **Misconception:** JSON can contain comments like // or /* */. **Reality:** 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.)
- **Misconception:** The `| json` pipe works on any Cisco IOS command. **Reality:** `| 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.)
- **Misconception:** JSON arrays can have a trailing comma after the last element. **Reality:** 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.)

## Key takeaways

- 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 [].

## FAQ

**What is JSON and why is it used in networking?**

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.

**How do I output JSON from a Cisco IOS command?**

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`).

**What are the common mistakes when writing 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.

**How do I access nested data in a JSON object?**

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.

**What is the difference between JSON and YAML?**

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.

**Can JSON contain comments?**

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.

**How do I convert XML to 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.

---

Interactive version with quiz and diagrams: https://courseiva.com/learn/ccna/json-networking