# Check If a String is Valid JSON in PHP

Ashley Allen ·

16th September 2025

## Introduction

As PHP developers, we often work with JSON. On an almost daily basis, I interact with JSON when [receiving data from an API](https://consuming-apis-in-laravel.com/), reading configuration files, returning API responses from my Laravel apps, accepting JSON input from users, and more.

There may be times when we need to validate whether a given string is valid JSON. This is especially important when dealing with user input or data from external sources, where the format may not be guaranteed.

In this [Quickfire](/content/blog?category=quickfire/index.html) article, we'll explore how to check whether a string is valid JSON in PHP using the built-in `json_validate` function.

## Check if a String is Valid JSON in PHP

The `json_validate` function was introduced in PHP 8.3 (released in November 2023) as a simple and efficient way to validate JSON strings.

It accepts a string as input and returns `true` if the string is valid JSON, or `false` otherwise.

For example, here's how we could use `json_validate`:

```
$jsonString = '{"name": "John", "age": 30, "city": "London"}';
$isValid = json_validate($jsonString);
// $isValid will be true
```

And here's an example of it returning `false` for an invalid JSON string:

```
// Missing closing brace
$invalidJsonString = '{"name": "John", "age": 30, "city": "London"';
$isValid = json_validate($invalidJsonString);
// $isValid will be false
```

As you can see, `json_validate` provides a straightforward way to check the validity of a JSON string.

However, it's important to remember that it isn't checking the contents of the JSON, just whether the string is properly formatted as JSON. For example, we can't use `json_validate` to check if a JSON string contains specific keys or values. If you want to do this, you'll need to decode the JSON and then inspect the resulting data structure.

### Retrieving the Error Message

If the `json_validate` function returns `false`, you can use `json_last_error()` to get the error code and `json_last_error_msg()` to get a descriptive error message. This is useful for debugging purposes or for providing feedback to users.

Let's see an example of this in action:

```
// Missing closing brace
$invalidJsonString = '{"name": "John", "age": 30, "city": "London"';
$isValid = json_validate($invalidJsonString);
if (!$isValid) {
    $errorCode = json_last_error();
    $errorMessage = json_last_error_msg();
}
// $errorCode will be: 4 (JSON_ERROR_SYNTAX)
// $errorMessage will be: "Syntax error"
```

For a full list of the possible error codes and their meaning, you can refer to the [PHP documentation for json_last_error()](https://www.php.net/manual/en/function.json-last-error.php).

## "json_validate" vs "json_decode"

You might be reading this and wondering, "Why not just use `json_decode` to check if a string is valid JSON?".

And that's a fair question!

In fact, there might be situations where you actually want to opt for `json_decode` instead of `json_validate`.

When you use `json_decode`, it implicitly validates the JSON as part of its operation. If the JSON is valid, it will return the decoded data structure (array or object). If the JSON is invalid, it will return `null`, and you can use `json_last_error()` to retrieve the error code (or use the `JSON_THROW_ON_ERROR` flag to throw an exception if the JSON is invalid).

However, `json_decode` can be more memory-intensive because it needs to build the data structure (e.g., arrays, objects, etc.) from the JSON string. In a lot of cases, this might be exactly what you want, especially if you're going to use the decoded data right away. But in other cases, you might not want to use the JSON immediately. You might just want to check whether it's valid before passing it on to something like a database, [cache](/content/blog/an-introduction-to-caching-in-laravel/index.html), or a queued job for processing later. In these scenarios, loading the entire data structure into memory is unnecessary overhead.

Granted, the memory difference might be negligible for small JSON strings, but it may become more significant when dealing with large JSON payloads or high-throughput applications. So if you're not immediately using the decoded data, `json_validate` is a more efficient choice because it doesn't need to build the data structure; it just checks the validity of the JSON string.

### Don't Parse the JSON Twice

It's important to remember that `json_validate` and `json_decode` both need to parse the JSON string to perform their operations. So if you use `json_validate` and then immediately follow it with `json_decode`, you're parsing the JSON string twice, which is inefficient.

As we've already mentioned, `json_decode` already validates the JSON as part of its operation. So you don't need to use `json_validate` first if you're going to decode the JSON right away.

`json_validate` is most useful when you _only_ want to check the validity of a JSON string, and then want to process it elsewhere later.

## Conclusion

Hopefully, this [Quickfire](/content/blog?category=quickfire/index.html) article has given you a good understanding of how to check if a string is valid JSON in PHP using the new `json_validate` function.

If you enjoyed reading this post, you might be interested in checking out my 220+ page ebook "[Battle Ready Laravel](https://battle-ready-laravel.com/)" which covers similar topics in more depth.

Or, you might want to check out my other 440+ page ebook "[Consuming APIs in Laravel](https://consuming-apis-in-laravel.com/)" which teaches you how to use Laravel to consume APIs from other services.

Keep on building awesome stuff! 🚀