Giant JSON Viewer: Complete Overview

Giant JSON Viewer is built for one purpose: viewing JSON files that other apps can't handle. Whether you're inspecting a 50MB API response or navigating a 5GB database export, the app uses a native Rust engine that operates outside Android's memory limits to keep things smooth.

This guide covers everything you need to know to get the most out of the app — from understanding how indexing works to mastering the three viewing modes.

How Indexing Works

When you first open a file, the app builds a structural index that maps where every object and array begins and ends (primitives like strings and numbers are not indexed individually). Indexing time depends on file complexity, device capabilities, and the number of nodes in the structure. A file with deeply nested structures takes longer than a large file with simple content — for example, a huge JSON with lots of encoded images will index faster than a smaller file with thousands of nested objects.

What the index enables:

• Instant navigation: Jump to any element without scanning from the beginning
• Smooth scrolling: Only the visible portion is loaded into memory
• Nearly instant reopening: Previously indexed files open almost immediately

The index is always stored in the app's cache directory, never alongside your files. You can see index status on each file's card in the Recent Files screen — the small badge shows whether an index exists. If the source file changes, the index is automatically invalidated and rebuilt on next open.

Storage Breakdown

Beyond the main index, the app creates additional data to enhance your experience:

Data Type	Purpose	Typical Size
Main Index	Structural map for navigation	~40 bytes per node
Keys Cache	Speeds up key auto-complete in filters	~50KB per file
Filter Indexes	Cached results for each unique filter	Varies by results
Bookmarks	Saved positions within files	~200 bytes each

You can view the complete storage breakdown for any file by tapping the index badge on its card in Recent Files. The dialog shows exactly what's using space.

The Three Viewing Modes

After opening a file and building the index, you choose how to view it. Each mode is optimized for different tasks.

Text Mode

The raw text viewer with powerful search capabilities.

What it's for

• String and regex-based searching across the entire file
• Counting search results nearly instantly across huge files
• Deep inspection of specific values (values below 50KB are shown in full)

Key features

• Syntax highlighting: Color-coded JSON elements (strings, numbers, objects, arrays, booleans)
• String and regex search: Find text or patterns using Rust-compatible regular expressions
• Occurrence counter: Count matches across the entire file without loading it all
• Go to line: Jump directly to any line number
• Line selection: Click line numbers to set a selection range. Long-tap the line counter to copy the entire selected lines to clipboard
• Custom highlight profiles: Create reusable highlighting rules — define patterns to highlight (e.g., "error" in red, "warning" in yellow) and save as profiles for quick switching

Example use cases

• Searching for all occurrences of a specific error code in server logs
• Counting how many times a particular field or value appears
• Examining the structure of an API response

Browser Mode

The interactive tree view. Navigate through your JSON like a file explorer.

What it's for

• Exploring data structures
• Drilling down into nested objects and arrays
• Filtering to find specific records
• Exporting subsets to CSV, SQL, or JSON
• Bookmarking specific elements for later reference

Key features

• Collapsible nodes: Expand and collapse objects/arrays with the +/- buttons on the right side
• Value previews: See truncated content without expanding
• JSONPath display: Long-tap a card to expand it and see the full JSONPath (e.g., $.users[42].profile.name)
• Copy path or value: Long-press to copy the path or raw value
• Sibling navigation: Jump between array elements with Previous/Next buttons
• Jump to path/index: Navigate directly to a specific JSONPath or array index
• Bookmarks: Swipe a card left to bookmark that specific element
• Hide elements: Swipe a card right to hide it

Filtering (Smart Filter)

The graphical filter builder lets you find exactly what you need without writing code:

1. Create a rule: Select KEY + OPERATOR + VALUE (e.g., status equals active)
2. Add more rules: Tap the ghost rule (+) to add another condition
3. Set logical relations: Choose AND/OR between rules
4. Group with parentheses: Tap the () button on rule cards to create logical groups

Example filter:

(gender = female
 AND
 isActive <> false)
OR
balance > 32242

Saved Filters: Filter results are cached per file. To re-run a previous filter, tap "SAVED FILTERS" at the top of the Filter screen.

Export Subset

When viewing an array of objects with consistent structure, the Export option appears:

• CSV: Tabular format for spreadsheets
• SQL: INSERT statements for databases (SQLite, MySQL, PostgreSQL)
• JSON: Pretty-printed, minified, or NDJSON

You can select which fields to include and rename keys during export.

Example use cases

• Finding all users with a specific status and exporting them to a spreadsheet
• Navigating to a deeply nested configuration value
• Bookmarking interesting values (e.g., server log entries to check later)
• Hiding non-relevant cards that cause noise while investigating

Structure Mode

The schema visualizer. Understand the shape of your data at a glance.

What it's for

• Understanding unfamiliar data structures
• Documenting API response formats
• Exporting schema definitions for development
• Getting a bird's-eye view before diving into the data

Key features

• Zoomable tree diagram: Pan and zoom through the entire structure
• Type indicators: See data types at each level (object, array, string, number, boolean, null)

Schema Export (with sampling options)

When exporting the schema, you can choose how to analyze the file (especially important for large files >100MB):

• First N: Analyze samples from the beginning
• Random: Analyze samples spread throughout the file
• All: Full scan (slower but complete analysis)

Export formats (experimental — please report issues on our GitHub):

• PNG: High-resolution image of the tree diagram
• TypeScript: Interface definitions with JSDoc comments
• JSON Schema: Draft-07 compatible schema
• Markdown: Human-readable documentation

The analyzer detects 43 semantic patterns to infer likely meanings (dates, URLs, emails, UUIDs, etc.) and uses majority-wins frequency tracking to determine the most common type at each path.

Tools

The Tools menu (accessible from the arc FAB on the Recent Files screen) provides standalone utilities:

Just Make Pretty

Formats JSON with proper indentation. Select a source file and output destination — it formats on the fly and saves the result. Faster than the full viewer because it doesn't build an index.

Use case: Quickly formatting a minified JSON file for easier reading.

Unescape JSON

Cleans up stringified JSON — the kind where quotes and special characters are escaped (\", \\n). Common in logs and API responses where JSON is embedded within JSON strings.

Use case: Extracting readable JSON from a log entry like {"payload": "{\"user\":\"alice\"}"}.

Schema Validation

Validates JSON files against a JSON Schema (Draft-07). Requires the file to be indexed first. Works on files of any size using streaming validation.

The key advantage: it doesn't just say VALID or NOT — it shows ALL validation errors with specific reasons and locations. And yes, you can export the error report... as JSON.

Use case: Verifying that a data export matches the expected schema before importing it elsewhere.

Recent Files & Storage

The main screen shows your recently opened files with useful metadata:

• File name: At-a-glance identification
• File size: Know what you're working with
• Index status: Badge shows if an index exists and is valid
• Remote indicator: Cloud icon for files downloaded via Remote API

Storage dialog (tap the index badge): See exactly how much space each file's data uses — index, cache, filters, bookmarks, and for remote files, the downloaded file itself.

Remote files: Files downloaded via Remote API are stored locally in the app's data folder. Removing a remote file from Recent Files permanently deletes the local copy. Uninstalling the app also removes these files.

Meet Bracey

You might have noticed the friendly curly brace character {} that appears throughout the app. That's Bracey, Giant JSON Viewer's mascot.

Think of Bracey as a helpful companion: a little tribute to those classic assistant guides from the '90s, but less intrusive and with better taste in file formats.

Summary

Mode	Best For	Key Feature
Text	Raw inspection, regex search	Pattern counting, line selection
Browser	Navigation, filtering, export	Smart Filter + Export Subset
Structure	Schema understanding, documentation	TypeScript/JSON Schema export

Giant JSON Viewer is designed to do one thing well: handle JSON files that other apps can't. The combination of native indexing, streaming access, and purpose-built tools makes it possible to work with multi-gigabyte files on a mobile device without crashes or freezes.