4 Best Ways to Remove Unicode Characters from JSON

To remove all Unicode characters from a JSON string in Python, load the JSON data into a dictionary using json.loads(). Traverse the dictionary and use the re.sub() method from the re module to substitute any Unicode character (matched by the regular expression pattern r'[^\x00-\x7F]+') with an empty string. Convert the updated dictionary back to a JSON string with json.dumps().

import json
import re

# Original JSON string with emojis and other Unicode characters
json_str = '{"text": "I love πŸ• and 🍦 on a β˜€οΈ day! \u200b \u1234"}'

# Load JSON data
data = json.loads(json_str)

# Remove all Unicode characters from the value
data['text'] = re.sub(r'[^\x00-\x7F]+', '', data['text'])

# Convert back to JSON string
new_json_str = json.dumps(data)

# {"text": "I love  and  on a  day!  "}

The text "I love πŸ• and 🍦 on a β˜€οΈ day! \u200b \u1234" contains various Unicode characters including emojis and other non-ASCII characters. The code will output {"text": "I love and on a day! "}, removing all the Unicode characters and leaving only the ASCII characters.

This is only one method, keep reading to learn about alternative ones and detailed explanations! πŸ‘‡

Occasionally, you may encounter unwanted Unicode characters in your JSON files, leading to problems with parsing and displaying the data. Removing these characters ensures clean, well-formatted JSON data that can be easily processed and analyzed.

In this article, we will explore some of the best practices to achieve this, providing you with the tools and techniques needed to clean up your JSON data efficiently.

Understanding Unicode Characters

Unicode is a character encoding standard that includes characters from most of the world’s writing systems. It allows for consistent representation and handling of text across different languages and platforms. In this section, you’ll learn about Unicode characters and how they relate to JSON.

πŸ’‘ JSON is natively designed to support Unicode, which means it can store and transmit information in various languages without any issues. When you store a string in JSON, it can include any valid Unicode character, making it easy to work with multilingual data. However, certain Unicode characters might cause problems in specific scenarios, such as when using older software or transmitting data over a limited bandwidth connection.

In JSON, certain characters must be escaped, like quotation marks, reverse solidus, and control characters (U+0000 through U+001F). These characters must be represented using escape sequences in order for the JSON to be properly parsed.

πŸ”— You can find more information about escaping characters in JSON through this Stack Overflow discussion.

There might be times where you need to remove or replace Unicode characters from your JSON data. One way to achieve this is by using encoding and decoding techniques. For example, you can encode a string to ASCII while ignoring non-ASCII characters, and then decode it back to UTF-8.

πŸ”— This method can be found in this Stack Overflow example.

The Basics of JSON

πŸ’‘ JSON (JavaScript Object Notation) is a lightweight, text-based data interchange format that is easy to read and write. It has become one of the most popular data formats for exchanging information on the web. When dealing with JSON data, you may encounter situations where you need to remove or modify Unicode characters.

JSON is built on two basic structures: objects and arrays.

  • An object is an unordered collection of key-value pairs, while
  • an array represents an ordered list of values.

A JSON file typically consists of a single object or array, containing different types of data such as strings, numbers, and other objects.

When working with JSON data, it is important to ensure that the text is properly formatted. This includes using appropriate escape characters for special characters, such as double quotes and backslashes, as well as handling any Unicode characters in the text. Keep in mind that JSON is a human-readable format, so a well-formatted JSON file should be easy to understand.

Since JSON data is text-based, you can easily manipulate it using standard text-processing techniques. For example, to remove unwanted Unicode characters from a JSON file, you can use a combination of encoding and decoding methods, like this:

json_data = json_data.encode("ascii", "ignore").decode("utf-8")

This process will remove all non-ASCII characters from the JSON data and return a new, cleaned-up version of the text.

How Unicode Characters Interact within JSON

In JSON, most Unicode characters can be freely placed within the string values. However, there are certain characters that must be escaped (i.e., replaced by a special sequence of characters) to be part of your JSON string. These characters include the quotation mark (U+0022), the reverse solidus (U+005C), and control characters ranging from U+0000 to U+001F.

When you encounter escaped Unicode characters in your JSON, they typically appear in a format like \uXXXX, where XXXX represents a 4-digit hexadecimal code. For example, the acute Γ© character can be represented as \u00E9. JSON parsers can understand this format and interpret it as the intended Unicode character.

Sometimes, you might need or want to remove these Unicode characters from your JSON data. This can be done in various ways, depending on the programming language you are using. In Python, for instance, you could leverage the encode and decode functions to remove unwanted Unicode characters:

cleaned_string = original_string.encode("ascii", "ignore").decode("utf-8")

In this code snippet, the encode function tries to convert the original string to ASCII, replacing Unicode characters with basic ASCII equivalents. The ignore parameter specifies that any non-ASCII characters should be left out. Finally, the decode function transforms the bytes back into a string.

Method 1: Encoding and Decoding JSONs

JSON supports Unicode character sets, including UTF-8, UTF-16, and UTF-32. UTF-8 is the most commonly used encoding for JSON texts and it is well-supported across different programming languages and platforms.

If you come across unwanted Unicode characters in your JSON data while parsing, you can use the built-in encoding and decoding functions provided by most languages. For example, in Python, the json.dumps() and json.loads() functions allow you to encode and decode JSON data respectively. To remove unwanted Unicode characters, you can use the encode() and decode() functions available in string objects:

json_data = '{"quote_text": "This is an example of a JSON file with unicode characters like \\u201c and \\u201d."}'
decoded_data = json.loads(json_data)
cleaned_text = decoded_data['quote_text'].encode("ascii", "ignore").decode('utf-8')

In this example, the encode() function is used with the "ascii" argument, which ignores unicode characters outside the ASCII range. The decode() function then converts the encoded bytes object back to a string.

When dealing with JSON APIs and web services, be aware that different programming languages and libraries may have specific methods for encoding and decoding JSON data. Always consult the documentation for the language or library you are working with to ensure proper handling of Unicode characters.

Method 2: Python Regex to Remove Unicode from JSON

A second approach is to use a regex pattern before loading the JSON data. By applying a regex pattern, you can remove specific Unicode characters. For example, in Python, you can implement this with the re module as follows:

import json
import re

def remove_unicode(input_string):
    return re.sub(r'\\u([0-9a-fA-F]{4})', '', input_string)

json_string = '{"text": "Welcome to the world of \\u2022 and \\u2019"}'
json_string = remove_unicode(json_string)
parsed_data = json.loads(json_string)

This code uses the remove_unicode function to strip away any Unicode entities before loading the JSON string. Once you have a clean JSON data, you can continue with further processing.

Method 3: Replace Non-ASCII Characters

Another approach to removing Unicode characters is to replace non-ASCII characters after decoding the JSON data. This method is useful when dealing with specific character sets. Here’s an example using Python:

import json

def remove_non_ascii(input_string):
    return ''.join(char for char in input_string if ord(char) < 128)

json_string = '{"text": "Welcome to the world of \\u2022 and \\u2019"}'
parsed_data = json.loads(json_string)
cleaned_data = {}

for key, value in parsed_data.items():
    cleaned_data[key] = remove_non_ascii(value)

# {'text': 'Welcome to the world of  and '}

In this example, the remove_non_ascii function iterates over each character in the input string and retains only the ASCII characters. By applying this to each value in the JSON data, you can efficiently remove any unwanted Unicode characters.

When working with languages like JavaScript, you can utilize external libraries to remove Unicode characters from JSON data. For instance, in a Node.js environment, you can use the lodash library for cleaning Unicode characters:

const _ = require('lodash');
const json = {"text": "Welcome to the world of β€’ and ’"};

const removeUnicode = (obj) => {
  return _.mapValues(obj, (value) => _.replace(value, /[\u2022\u2019]/g, ''));

const cleanedJson = removeUnicode(json);

In this example, the removeUnicode function leverages Lodash’s mapValues and replace functions to remove specific Unicode characters from the JSON object.

Handling Specific Unicode Characters in JSON

Dealing with Control Characters

Control characters are special non-printing characters in Unicode, such as carriage returns, linefeeds, and tabs. JSON requires that these characters be escaped in strings. When dealing with JSON data that contains control characters, it’s essential to escape them properly to avoid potential errors when parsing the data.

For instance, you can use the json.dumps() function in Python to output a JSON string with control characters escaped:

import json

data = {
  "text": "This is a string with a newline character\nin it."

json_string = json.dumps(data)

This would output the following JSON string with the newline character escaped:

{"text": "This is a string with a newline character\\nin it."}

When you parse this JSON string, the control character will be correctly interpreted, and you’ll be able to access the data as expected.

Addressing Non-ASCII Characters

JSON strings can also contain non-ASCII Unicode characters, such as those from other languages. These characters may sometimes cause problems when processing JSON data in applications that don’t handle Unicode well.

One option is to escape non-ASCII characters when encoding the JSON data. You can do this by setting the ensure_ascii parameter of the json.dumps() function to True:

import json

data = {
  "text": "γ“γ‚“γ«γ‘γ―γ€δΈ–η•ŒοΌ"  # Japanese for "Hello, World!"

json_string = json.dumps(data, ensure_ascii=True)

This will output the JSON string with the non-ASCII characters escaped:

{"text": "\u3053\u3093\u306b\u3061\u306f\u3001\u4e16\u754c\u0021"}

However, if you’d rather preserve the original non-ASCII characters in the JSON output, you can set ensure_ascii to False:

json_string = json.dumps(data, ensure_ascii=False)

In this case, the output would be:

{"text": "γ“γ‚“γ«γ‘γ―γ€δΈ–η•ŒοΌ"}

Keep in mind that when working with non-ASCII characters in JSON, it’s essential to use tools and libraries that support Unicode. This ensures that the data is correctly processed and displayed in your application.

Examples: Implementing the Unicode Removal

Before starting with the examples, make sure you have your JSON object ready for manipulation. In this section, you’ll explore different methods to remove unwanted Unicode characters from JSON objects, focusing on JavaScript implementation.

First, let’s look at a simple example using JavaScript’s replace() function and a regular expression. The following code showcases how to remove Unicode characters from a JSON string:

const jsonString = '{"message": "𝕴 𝖆𝖒 𝕴𝖗𝖔𝖓𝖒𝖆𝖓! I have some unicode characters."}';
const withoutUnicode = jsonString.replace(/[\u{0080}-\u{FFFF}]/gu, "");

In the code above, the regular expression \u{0080}-\u{FFFF} covers most of the Unicode characters you might want to remove. By using the replace() function, you can replace those characters with an empty string ("").

Next, for more complex scenarios involving nested JSON objects, consider using a recursive function to traverse and clean up Unicode characters from the JSON data:

function cleanUnicode(jsonData) {
  if (Array.isArray(jsonData)) {
    return jsonData.map(item => cleanUnicode(item));
  } else if (typeof jsonData === "object" &#x26;&#x26; jsonData !== null) {
    const cleanedObject = {};
    for (const key in jsonData) {
      cleanedObject[key] = cleanUnicode(jsonData[key]);
    return cleanedObject;
  } else if (typeof jsonData === "string") {
    return jsonData.replace(/[\u{0080}-\u{FFFF}]/gu, "");
  } else {
    return jsonData;

const jsonObject = {
  message: "𝕴 𝖆𝖒 𝕴𝖗𝖔𝖓𝖒𝖆𝖓! I have some unicode characters.",
  nested: {
    text: "π•Ύπ–”π–’π–Š π–šπ–“π–Žπ–ˆπ–”π–‰π–Š π–ˆπ–π–†π–—π–†π–ˆπ–™π–Šπ–—π–˜ π–π–Šπ–—π–Š 𝖙𝖔𝖔!"

const cleanedJson = cleanUnicode(jsonObject);

This cleanUnicode function processes arrays, objects, and strings, making it ideal for nested JSON data.

In conclusion, use the simple replace() method for single JSON strings, and consider a recursive approach for nested JSON data. Utilize these examples to confidently, cleanly, and effectively remove Unicode characters from your JSON data in JavaScript.

Common Errors and How to Resolve Them

When working with JSON data involving Unicode characters, you might encounter a few common errors that can easily be resolved. In this section, we will discuss these errors and provide solutions to overcome them.

One commonly observed issue is the presence of invalid Unicode characters in the JSON data. This can lead to decoding errors while parsing. To overcome this, you can employ a Python library called unidecode to remove accents and normalize the Unicode string into the closest possible representation in ASCII text. For example, using the unidecode library, you can transform a word like “FranΓ§ois” into “Francois”:

from unidecode import unidecode
unidecode('François')  # Output: 'Francois'

Another common error arises due to the presence of special characters in JSON data, which leads to parsing issues. Proper escaping of special characters is essential for building valid JSON strings. You can use the json.dumps() function in Python to automatically escape special characters in JSON strings. For instance:

import json
raw_data = {"text": "A string with special characters: \\, \", \'"}
json_string = json.dumps(raw_data)

Remember, it’s crucial to produce only 100% compliant JSON, as mentioned in RFC 4627. Ensuring that you follow these guidelines will help you avoid most of the common errors while handling Unicode characters in JSON.

Lastly, if you encounter non-compliant Unicode characters in text files, you can use a text editor like Notepad to remove them. For instance, you can save the file in Unicode format instead of the default ANSI format, which will help preserve the integrity of the Unicode characters.

By addressing these common errors, you’ll be able to effectively handle and process JSON data containing Unicode characters.


In summary, removing Unicode characters from JSON can be achieved using various methods. One approach is to encode the JSON string to ASCII and then decode it back to UTF-8. This method allows you to eliminate all Unicode characters in one go. For example, you can use the .encode("ascii", "ignore").decode('utf-8') technique to accomplish this, as explained on Stack Overflow.

Another option is applying regular expressions to target specific unwanted Unicode characters, as discussed in this Stack Overflow post. Employing regular expressions enables you to fine-tune your removal of specific Unicode characters from JSON strings.

Frequently Asked Questions

How to eliminate UTF-8 characters in Python?

To eliminate UTF-8 characters in Python, you can use the encode() and decode() methods. First, encode the string using ascii encoding with the ignore option, and then decode it back to utf-8. For example:

text = "Hello δ½ ε₯½"
sanitized_text = text.encode("ascii", "ignore").decode("utf-8")

What are the methods to remove non-ASCII characters in Python?

There are several methods to remove non-ASCII characters in Python:

  1. Using the encode() and decode() methods as mentioned above.
  2. Using a regular expression to filter out non-ASCII characters: re.sub(r'[^\x00-\x7F]+', '', text)
  3. Using a list comprehension to create a new string with only ASCII characters: ''.join(c for c in text if ord(c) < 128)

How can Pandas be used to remove Unicode characters?

To remove Unicode characters in a Pandas dataframe, you can use the applymap() function combined with the encode() and decode() methods:

import pandas as pd

def sanitize(text):
    return text.encode("ascii", "ignore").decode("utf-8")

df = pd.DataFrame({"text": ["Hello δ½ ε₯½", "Pandas rocks!"]})
df["sanitized_text"] = df["text"].apply(sanitize)

What is the process to replace Unicode in JSON?

To replace Unicode characters in a JSON object, you can first convert the JSON object to a string using the json.dumps() method. Then, replace the Unicode characters using one of the methods mentioned earlier. Finally, parse the sanitized string back to a JSON object using the json.loads() method:

import json
import re

json_data = {"text": "Hello δ½ ε₯½"}
json_str = json.dumps(json_data)
sanitized_str = re.sub(r'[^\x00-\x7F]+', '', json_str)
sanitized_json = json.loads(sanitized_str)

How to convert Unicode to JSON format in Python?

If you have a Python object containing Unicode strings and want to convert it to JSON format, use the json.dumps() method:

import json

data = {"text": "Hello δ½ ε₯½"}
json_data = json.dumps(data, ensure_ascii=False)

This will preserve the Unicode characters in the JSON output.

How can special characters be removed from a JSON file?

To remove special characters from a JSON file, first read the file and parse its content to a Python object using the json.loads() method. Then, iterate through the object and sanitize the strings, removing special characters using one of the mentioned methods. Finally, write the sanitized object back to a JSON file using the json.dump() method:

import json
import re

with open("input.json", "r") as f:
    json_data = json.load(f)

# sanitize your JSON object here

with open("output.json", "w") as f:
    json.dump(sanitized_json_data, f)