Pretty Formatting JSON Output in Ruby on Rails

By the end of this page, you will understand how pretty-printed JSON works in Ruby and Ruby on Rails, why to_json usually returns compact JSON, and how to generate readable JSON for debugging, logs, and development tools using methods like JSON.pretty_generate.

JSON can be represented in two main ways:

• Compact JSON: everything on one line, with no extra spaces or indentation
• Pretty JSON: formatted with line breaks and indentation for readability

In Ruby on Rails, calling to_json usually produces compact JSON. That is useful for machines because it keeps the payload small, but it is harder for humans to read.

Pretty formatting matters when you want to:

• debug API responses
• inspect nested data structures
• read logs more easily
• compare JSON output during development

It is important to understand that pretty formatting changes the appearance, not the data itself. The JSON content is still the same. Only whitespace is added.

In Ruby, pretty-printing JSON is commonly done with the standard json library:

require 'json'

JSON.pretty_generate(hash)

This converts a Ruby hash or array into nicely indented JSON.

In Rails projects, this is often used for:

• debugging in the console
• rendering readable output in development
• logging structured data

For production API responses, developers often keep JSON compact because extra whitespace increases response size.

Think of JSON like a paragraph of text.

• Compact JSON is like one very long sentence with no line breaks.
• Pretty JSON is like the same text split into paragraphs and bullet points.

The meaning does not change. It just becomes easier for a human to scan.

So, pretty-printing JSON is like asking a computer to rewrite the same information in a cleaner layout.

The most common way to pretty format JSON in Ruby is with JSON.pretty_generate.

require 'json'

data = {
  name: "Alice",
  age: 30,
  admin: true,
  skills: ["Ruby", "Rails"]
}

puts JSON.pretty_generate(data)

Output:

{
  "name": "Alice",
  "age": 30,
  "admin": true,
  "skills": [
    "Ruby",
    "Rails"
  ]
}

Using it with JSON strings

If you already have a JSON string, parse it first, then pretty print it:

 

json_string = 
parsed = .parse(json_string)

puts .pretty_generate(parsed)

Consider this example:

require 'json'

data = {
  user: {
    name: "Alice",
    age: 30
  },
  active: true
}

pretty = JSON.pretty_generate(data)
puts pretty

Here is what happens step by step:

1. require 'json'

   • Loads Ruby's JSON library.

2. data = { ... }

   • Creates a Ruby hash containing nested data.

3. JSON.pretty_generate(data)

   • Ruby reads the hash.
   • It converts the hash into valid JSON.
   • It inserts indentation and line breaks.
   • The result is a string.

4. pretty = ...

   • Stores that formatted JSON string in the pretty variable.

5. puts pretty

   • Prints the formatted JSON to the terminal or log.

Pretty-printed JSON is most useful when humans need to read it.

Debugging API responses

When building a Rails API, you may want to inspect nested objects:

puts JSON.pretty_generate(@order.as_json(include: :line_items))

Logging structured data

Readable logs are easier to troubleshoot:

Rails.logger.debug JSON.pretty_generate(payload)

Console inspection

In the Rails console, pretty JSON helps you understand complex objects:

puts JSON.pretty_generate(User.first.as_json)

Saving debug snapshots

You might save formatted JSON to a file while investigating an issue:

File.write("debug.json", JSON.pretty_generate(data))

Comparing outputs in tests or during development

Pretty formatting makes it easier to visually compare expected and actual JSON structures.

In real Rails codebases, developers usually separate data generation from display formatting.

Common pattern: build data with as_json

payload = @user.as_json(only: [:id, :name, :email])
Rails.logger.debug(JSON.pretty_generate(payload))

This avoids mixing serialization logic with presentation.

Guard clause for optional debug output

payload = @user.as_json

if Rails.env.development?
  puts JSON.pretty_generate(payload)
end

This keeps pretty output limited to development.

Error investigation

When handling failures, developers often log a readable payload:

begin
  process_payload(payload)
rescue => e
  Rails.logger.error(e.message)
  Rails.logger.error(JSON.pretty_generate(payload))
end

Configuration awareness

Pretty JSON is usually not enabled globally for all responses in production because:

1. Using to_json and expecting pretty output

data = { name: "Alice" }
puts data.to_json

This usually outputs compact JSON on one line.

Fix:

require 'json'
puts JSON.pretty_generate(data)

2. Pretty-printing an already encoded JSON string incorrectly

Broken example:

json_string = '{"name":"Alice"}'
puts JSON.pretty_generate(json_string)

This treats the whole string as a plain Ruby string, not as parsed JSON data.

Fix:

parsed = JSON.parse(json_string)
puts JSON.pretty_generate(parsed)

3. Confusing as_json with to_json

• as_json returns a Ruby hash or array
• to_json returns a JSON string

as_json vs to_json

require 'json'

Pretty print a Ruby hash

JSON.pretty_generate(data)

Pretty print a Rails object

JSON.pretty_generate(@user.as_json)

Pretty print an existing JSON string

parsed = JSON.parse(json_string)
JSON.pretty_generate(parsed)

Key rules

• to_json -> returns a JSON string
• as_json -> returns a Ruby hash or array
• JSON.pretty_generate(...) -> returns formatted JSON string
• Pretty formatting changes whitespace only, not the actual data
• Use pretty JSON mainly for debugging, logs, and development

Common pattern

payload = object.as_json
puts JSON.pretty_generate(payload)

Watch out for

• Passing a raw JSON string directly to

How do I pretty print JSON in Ruby on Rails?

Use Ruby's JSON library with JSON.pretty_generate:

JSON.pretty_generate(@object.as_json)

Why does to_json return one line?

to_json is designed to generate compact JSON by default. This is efficient for machines and network responses.

Should I use pretty JSON in production APIs?

Usually no. Pretty JSON is easier for humans to read, but it increases response size. Most production APIs use compact JSON.

What is the difference between as_json and to_json in Rails?

as_json returns a Ruby structure, while to_json returns a JSON string.

Can I pretty print a JSON string I already have?

Yes. First parse it, then pretty print it:

JSON.pretty_generate(JSON.parse(json_string))

Does pretty formatting change the JSON data?

No. It only adds spaces and line breaks for readability.

Can I use pretty JSON for logging?

• as_json — Related because it prepares Ruby objects for JSON serialization.
• to_json — Related because it converts Ruby objects directly into JSON strings.
• JSON.parse — Related because it turns JSON strings back into Ruby data structures.
• API rendering in Rails — Related because Rails commonly returns JSON from controllers.
• Serialization — Related because JSON output is part of converting objects into transferable data.
• Logging in Rails — Related because pretty JSON is often used to make structured logs easier to read.
• Debugging data structures — Related because pretty printing helps inspect nested hashes and arrays.