JSON to PHP Array

Q: Should I use the short syntax or array()?

Short syntax — square brackets — unless you are maintaining code that predates PHP 5.4, which was released in 2012. It is the modern convention, it is shorter, and it nests far more readably. The long array() form is offered because some older codebases still use it consistently, and matching the surrounding style matters more than being modern. Both produce identical arrays; the choice is purely about what the file around it looks like.

Q: Why not just use json_decode at runtime?

For data arriving over the wire, you absolutely should — decoding is what it is for, and pasting a payload into your source would be strange. This tool is for the other case: data that is genuinely part of your code. A config array, a lookup table, a test fixture, a seed file. Embedding those as a literal means no file read, no parse step, no failure mode at runtime, and the value is visible in the source where someone maintaining it will actually see it.

Q: How are quotes and backslashes escaped?

Single-quoted strings are used throughout, which is the safer choice because PHP only interprets two escape sequences inside them: a backslash before a quote, and a backslash before a backslash. Everything else — dollar signs, newlines, tabs — is literal. That means a value containing $variable stays as those exact characters rather than being interpolated, which is what you want for data. Double-quoted strings would interpolate, and a value from JSON is not a template.

Q: Does a JSON array become a PHP list?

Yes. A JSON array becomes a PHP array with no explicit keys, so it gets sequential integer keys starting at zero — which is what PHP calls a list and what array functions expect. Writing the indices out explicitly would be noise, since they would be 0, 1, 2 anyway. A JSON object becomes an associative array with its keys quoted. This mapping is exactly what json_decode with the associative flag produces, so the literal matches what decoding would have given you.

Q: What happens to a very large or deeply nested document?

It converts, but consider whether it should be a literal at all. A few hundred lines of array is readable and reviewable in a diff; ten thousand is neither, and it belongs in a data file or a database instead. Deep nesting is a separate concern — an array nested six levels deep is hard to read in any syntax, and the fact that it converts cleanly does not mean embedding it is the right structure for your code.

Q: Will the numbers survive exactly?

Ordinary values will. The caveat is very large integers: JSON has no precision limit written into the format, while PHP integers are platform-bound, so a value beyond PHP_INT_MAX becomes a float and loses exactness. That matters for things like large database ids and Twitter-style snowflake identifiers, which are usually better handled as strings on both sides. If your data has integers beyond about nine quintillion, quote them in the source JSON before converting.

Convert JSON into a PHP array literal with correct single-quote escaping, short or long syntax and configurable indentation.

JSON

Variable name

Array syntax

Indent

PHP

Conversion happens entirely in your browser. Strings are single-quoted so dollar signs stay literal rather than being interpolated as variables.

What It Does

Turns a JSON document into a PHP array literal you can paste straight into a source file. It is for the case where the data genuinely belongs in your code — a config block, a lookup table, a test fixture, a seed file — rather than for anything arriving over the wire, which json_decode should handle at runtime. The output uses single-quoted strings throughout, which is deliberate: PHP interprets only two escape sequences inside them, so a value containing a dollar sign stays literal instead of being interpolated as a variable. JSON arrays become PHP lists with implicit integer keys and objects become associative arrays, which is exactly the mapping json_decode produces, so the literal matches what decoding would have given you.

When to Use It

A configuration block arrived as JSON and belongs in a PHP config file rather than being read at runtime.
You need a test fixture as a literal so the expected value is visible in the test itself.
A seed file needs data you already have as JSON from an export or an API response.
You are moving a lookup table out of a database and into code where it can be version controlled.
A colleague sent a payload and you want it in a shape you can paste into a PHP script to experiment with.

Worked Examples

{"name":"Jane","age":30,"active":true,"nickname":null}

The basics. PHP spells true, false and null the same way JSON does, so those pass through unchanged — unlike Python, where getting this wrong produces code that fails immediately.

{"note":"O'Brien's $rate went up"}

The escaping case. The apostrophe is escaped with a backslash, and the dollar sign is left completely alone — single quotes do not interpolate, which is why they are the right choice for data.

{"users":[{"id":1},{"id":2}],"meta":{"total":2}}

Mixed structures. The users array becomes a PHP list with implicit numeric keys, while meta becomes an associative array with quoted string keys — the same mapping json_decode would produce.

Features

PHP array literal from any JSON document

Short bracket or long array() syntax

Single-quoted strings with correct escaping

Dollar signs left literal rather than interpolated

JSON arrays become PHP lists with implicit keys

Configurable indentation width

Optional variable assignment or a bare literal

Nested structures indented readably

Empty arrays and objects emitted compactly

Runs entirely in your browser

How to Use

1. Paste your JSON into the input box. 2. The PHP array appears immediately below. 3. Choose short or long array syntax to match the file you are pasting into. 4. Set the indent width and the variable name, or clear the name for a bare literal. 5. Copy the result into your PHP source.

Common Mistakes

Using double-quoted strings for data. PHP interpolates them, so a value containing $name becomes whatever that variable holds — or an empty string and a warning.
Pasting a runtime payload into source. Data arriving over the wire should be decoded with json_decode; embedding it freezes a snapshot that will drift out of date silently.
Embedding a very large document as a literal. A few hundred lines is reviewable in a diff; ten thousand is not, and belongs in a data file.
Assuming huge integers survive. Values beyond PHP_INT_MAX become floats and lose exactness — quote large ids as strings before converting.
Mixing array syntaxes in one codebase. Both work identically, but consistency with the surrounding file matters more than which one you prefer.

Frequently Asked Questions

Should I use the short syntax or array()?

Why not just use json_decode at runtime?

How are quotes and backslashes escaped?

Does a JSON array become a PHP list?

What happens to a very large or deeply nested document?

Will the numbers survive exactly?