JSON Data Analysis in the Browser: From Unreadable Blobs to SQL-Queryable Tables

You make an API call. You get JSON back. And you stare at this:

{"data":{"results":[{"id":"a1b2","attributes":{"region":{"code":"EU","name":"Europe"},"metrics":{"revenue":48291.5,"orders":342,"returns":12}},"relationships":{"product":{"data":{"id":"p99","type":"products"}}}},{"id":"c3d4",...

It goes on for 800 lines. The data is in there. Somewhere. You know it is. But reading it feels like decoding a transmission from a satellite that doesn't want to be understood.

This is the daily reality for anyone who works with external APIs — financial feeds, government data portals, CRM exports, analytics platforms. The data exists. The access exists. But the gap between "raw JSON" and "useful analysis" is significant, and most tools don't help you cross it efficiently.

This article is about how to do JSON data analysis in the browser — specifically, how to take raw API JSON, flatten it into structured tables, and run SQL queries on it without writing a single line of code.

---

The Problem with Raw JSON for Data Analysis

Nesting Is the Enemy of Analysis

Relational databases store data in flat tables: rows and columns. SQL was designed for flat tables. Human brains think in flat tables. JSON was designed for something different — a flexible, hierarchical format for transmitting structured data between applications.

Nesting is JSON's superpower as a data format. It's also its curse for analysis. When a single "record" looks like:

{
  "id": "a1b2",
  "attributes": {
    "region": {
      "code": "EU",
      "name": "Europe"
    },
    "metrics": {
      "revenue": 48291.5,
      "orders": 342
    }
  }
}

...you have a hierarchy three levels deep. To query revenue by region.name, you first have to flatten that structure. attributes.region.name becomes region_name. attributes.metrics.revenue becomes revenue. That flattening is necessary for SQL and non-trivial to do manually.

Arrays of Objects Are a Common Pattern That Breaks Most Tools

Most APIs return arrays: {"results": [...]}. The results array contains objects. Each object might have nested objects. And some of those nested fields might themselves be arrays. This is completely normal JSON. It's also completely incompatible with the flat-file assumptions of most analysis tools.

Paste that JSON into Excel and watch what happens. You get [object Object] in every cell where a nested structure was. The data is lost. You have to pre-process the JSON before Excel can do anything with it, which means writing code or using Power Query in non-obvious ways.

Tools That "Handle" JSON Are Mostly JSON Formatters

Search for "JSON data analysis browser" and you'll find a lot of JSON formatters and viewers. They pretty-print the JSON. They add collapsible tree views. They let you search within the structure. These are useful for reading JSON, but they're not analytical tools. They don't flatten, they don't query, they don't aggregate. They just make the JSON a little less visually painful.

The gap between "JSON viewer" and "JSON analysis tool" is enormous, and most tools sit firmly in the first category.

Python/Pandas Is the Standard Solution — And It Has a High Tax

The de facto solution for JSON data analysis is Python: call the API with requests, normalize the response with pandas.json_normalize(), then query and analyze with DataFrame operations or SQL via pandasql. This works. Data engineers do it every day.

But it requires:

• Python installed and configured
• Knowledge of the requests, pandas, and optionally pandasql libraries
• Writing code every time you explore a new API
• Debugging JSON normalization for each unique response structure
• Running a local environment or Jupyter server

For a data analyst who wants to quickly check whether an API is useful, or pull a one-time dataset for a report, this is a lot of friction for what should be a simple task.

---

Try it yourself — Start exploring for free. No credit card. 8 demo data sources ready to query.

---

What JSON Data Analysis in the Browser Should Look Like

The ideal browser-based JSON analysis tool would:

1. Accept an API URL directly — no copy-pasting JSON manually
2. Handle authentication transparently (API keys, headers)
3. Automatically detect and flatten nested JSON structures
4. Detect field types and assign them correctly (string, number, date)
5. Handle paginated responses to get complete datasets
6. Present the result as a clean, sortable, filterable table
7. Provide a full SQL interface for aggregation, filtering, and joining
8. Export to CSV with one click
9. Work entirely in the browser — no installation

Harbinger Explorer delivers all of this. It's the only browser-based tool purpose-built for the complete workflow: API URL → structured table → SQL analysis → export.

The AI Crawler: JSON Flattening Made Automatic

The core of Harbinger Explorer is the AI Crawler. When you give it an API endpoint, it does the hard part automatically:

Schema Detection: It reads the JSON response and identifies every field, including those nested two or three levels deep. attributes.metrics.revenue becomes a column called metrics_revenue (or renamed via Column Mapping to just revenue). Arrays are handled with intelligent expansion logic.

Type Inference: The crawler detects field types from the actual data. A field full of "2025-01-15" values is inferred as a date. A field of 0.0, 1.5, 42.0 is numeric. Types are assigned correctly so your SQL and aggregations work without surprises.

Pagination Handling: Most APIs return results in pages. The crawler follows pagination links (next URLs, offset/limit patterns, cursor-based pagination) to pull complete datasets — not just the first page. You see all the data, not a sample.

Structured Output: The result of a crawl is a clean, tabular schema: column names, types, and a live preview of the first N rows. No JSON in sight.

This is the transformation from unreadable blob to queryable table — done automatically, in under 30 seconds, for most REST APIs.

DuckDB SQL: Analysis Directly on the Flattened Data

Once your JSON data is crawled and structured, you query it with DuckDB SQL. DuckDB is a best-in-class in-process analytical database — the same engine used in serious data engineering workflows, now accessible directly in the browser.

The SQL you write in Harbinger Explorer is not a simplified query language. It's full DuckDB SQL:

Aggregations: SELECT region_name, SUM(revenue), COUNT(*) FROM source GROUP BY region_name ORDER BY 2 DESC

Window Functions: SELECT id, revenue, RANK() OVER (PARTITION BY region_name ORDER BY revenue DESC) AS rank FROM source

CTEs for Multi-Step Analysis:

WITH monthly AS (
  SELECT DATE_TRUNC('month', created_date) AS month, SUM(revenue) AS rev
  FROM source
  GROUP BY 1
)
SELECT month, rev, rev - LAG(rev) OVER (ORDER BY month) AS mom_change
FROM monthly

JOINs Across Sources: SELECT a.id, a.revenue, b.product_name FROM sales_api a JOIN catalog_api b ON a.product_id = b.id

This is full analytical SQL running against API-sourced, JSON-derived data, directly in the browser.

---

Step-by-Step: JSON Analysis Without Code

Here's the complete workflow, from API URL to SQL results:

Step 1: Sign up and open Harbinger Explorer Register at harbingerexplorer.com/register. No credit card needed. The platform loads in your browser — nothing to install.

Step 2: Add your API source Click "Add Source." Enter the API endpoint URL. If the API requires a key, add it as a request header (e.g., Authorization: Bearer your_key_here) or a query parameter. Preview the raw response if you want to check you've got the right URL.

Step 3: Run the AI Crawler Click "Crawl." Watch the crawler work: it fetches all pages, maps the schema, flattens nested objects, detects types. In 10–30 seconds, you see a table.

Step 4: Review the schema Before writing any SQL, scan the column list. Check that the types look right. Check that nested fields have been flattened with sensible names. If anything needs renaming, use Column Mapping.

Step 5: Use Column Mapping for cleaner queries Find any columns with cryptic names from the API — attr_reg_cd for region code, dt_cr for creation date. Rename them. This takes 2 minutes and makes every future query more readable.

Step 6: Write SQL queries Open the SQL editor. Start with SELECT * FROM source LIMIT 20 to confirm everything looks right. Then build out your actual analysis:

• Filter: WHERE region = 'Europe' AND revenue > 10000
• Aggregate: SELECT category, AVG(revenue) FROM source GROUP BY category
• Rank: SELECT *, RANK() OVER (PARTITION BY category ORDER BY revenue DESC) AS rnk FROM source

Step 7: Export results When your query is complete, click "Export CSV." Your analysis lands in a clean spreadsheet-ready file. Or save the query for the next time you need it.

Total time: 3–5 minutes from URL to exported analysis. Previously: 30+ minutes with Python or manual JSON wrangling.

---

Advanced Features for Complex JSON Analysis

Multi-Level Nesting Support

Not all JSON is one level deep. Some APIs return objects nested four or five levels. The AI Crawler handles multi-level nesting with configurable flattening strategies. You choose how deep to flatten and how to name the resulting columns.

Array Explosion

Some JSON fields are arrays within records — tags, categories, items lists. Harbinger Explorer can "explode" these arrays, creating one row per array element. This is the equivalent of SQL's UNNEST operation, done automatically based on the data structure.

Cross-Source Joins for Enrichment

JSON from one API often references IDs that mean something in another API. Harbinger Explorer lets you crawl both sources and JOIN them in SQL. Enrich your primary dataset with reference data from another endpoint, all in one query — no ETL pipeline required.

PII Detection Before Export

If your JSON contains user data — emails, phone numbers, names — Harbinger Explorer's PII Detection scans the crawled data and flags sensitive fields. This gives you a governance checkpoint before you export or share results.

Scheduled Recrawls for Fresh Data

On Pro plans, configure Harbinger Explorer to recrawl your API on a schedule. Your saved queries always run against fresh data. This transforms one-time JSON analysis into an ongoing, automatically-refreshed data source.

---

Comparison: JSON Data Analysis Options

---

Pricing: Starter at €8/month (25 chats/day, 10 crawls/month) or Pro at €24/month (200 chats/day, 100 crawls/month, recrawling, priority support). See pricing →

Free 7-day trial, no credit card required. Start free →

---

Frequently Asked Questions

What types of JSON structures does the AI Crawler handle? The AI Crawler handles flat objects, nested objects, arrays of objects, mixed types, and most common REST API response patterns. Very unusual structures or binary-embedded JSON may need manual configuration. For standard public and commercial APIs, it works automatically.

Can I analyze JSON that I have locally, not from an API? Harbinger Explorer is primarily designed to work with live API endpoints rather than local files. If you have a static JSON file, you'd need to host it somewhere accessible. API-first analysis is the primary use case.

How does it handle large JSON responses with thousands of records? The AI Crawler handles pagination to pull complete datasets. For very large APIs, you can configure limits on how many pages to crawl. DuckDB, the SQL engine, is designed for analytical workloads and handles millions of records efficiently.

Is the JSON data stored securely? Yes. Crawled data is encrypted at rest, tied to your account, and not accessible to other users. You can delete any crawled source at any time. Harbinger Explorer's PII Detection helps you identify sensitive fields before they're exported or shared.

Does it work for real-time or streaming JSON? Harbinger Explorer crawls REST APIs that return JSON. True streaming or WebSocket-based data is not currently supported. For frequently updated data, scheduled recrawling (Pro feature) keeps data fresh on your chosen interval.

---

Conclusion: From JSON Blob to SQL in 2 Minutes

Raw JSON is not analysis-ready. Never has been. The work of turning it into something useful — flattening, typing, querying, exporting — has always been the analyst's burden: Python scripts, Power Query gymnastics, manual copy-paste into Excel.

Harbinger Explorer automates that burden. Paste an API URL. Let the AI Crawler do the flattening. Query the structured data with full SQL. Export the results.

JSON data analysis in the browser, without code, without setup, without the 30-minute manual pipeline that used to stand between you and your answer.

The demo sources are ready the moment you register. Try it and see how fast the analysis actually gets.

---

Ready to skip the setup and start exploring? Try Harbinger Explorer free →

---