In the RFC https://www.rfc-editor.org/rfc/rfc7159, it says:

JSON text SHALL be encoded in UTF-8, UTF-16, or UTF-32

At first glance it does seem that Python isn't really following the spec when you first look at this after all what does it mean to encode something when it remains a Python3 'str' string, however Python is doing some encoding for you nonetheless. Try this:

>>> json.dumps({"Japan":"日本"})
'{"Japan": "\\u65e5\\u672c"}'

You can see that the Japanese has got converted to unicode escapes, and the resultant string is actually ASCII, even if it's still a Python str. I'm unsure how to get json.dumps() to actually give you utf-8 sequences - for interoperability purposes - if you wanted them, however for all practical purposes this is good enough for most people. The characters are there and will be interpreted correctly. It's easy to get binary with:

>>> json.dumps({"Japan":"日本"}).encode("ascii")
b'{"Japan": "\\u65e5\\u672c"}'

And python does the right thing when loading back in:

>>> json.loads(json.dumps({"Japan":"日本"}).encode("ascii"))
{'Japan': '日本'}

But if you don't bother encoding at all, the loads() still figures out what to do as well when given a str:

>>> json.loads(json.dumps({"Japan":"日本"}))
{'Japan': '日本'}

Python is - as ever - trying to be as helpful as possible in figuring out what you want and doing it, but this is perplexing to people who dig a little deeper, and in spite of loving Python to bits I sympathise with the OP. Whether this kind of 'helpful' behaviour is worth the confusion is a debate that will rage on.

Worth noting that if the next thing to be done with the output is writing to a file, then you can just do:

pathlib.Path("myfile.json").open("w").write(json_data)

Then you don't need it binary because the file is opened in text mode and encoding is done for you.

You need to decode it then split by '\n' and load each json object separately. If you store your byte string in a variable called byte_string you could do something like:

json_str = byte_string.decode('utf-8')
json_objs = json_str.split('\n')
for obj in json_objs:
    json.loads(obj)

For the particular string that you have posted here though, you will get an error on the second object because the second key in it is missing a double quote. It is name" in the string you linked.

That's the base64 encoding of the contents of a zip file. You can turn it into a file with this.

s = 'UEsDBAoAAAAAALi8T0+jHCkcDAAAAAwAAAAMAAAASUJNX0RhdGEudHh0SGVsbG8gV29ybGQhUEsBAj8ACgAAAAAAuLxPT6McKRwMAAAADAAAAAwAJAAAAAAAAAAgAAAAAAAAAElCTV9EYXRhLnR4dAoAIAAAAAAAAQAYADZQuhPTg9UB2UqCCNOD1QHZSoII04PVAVBLBQYAAAAAAQABAF4AAAA2AAAAAAA='
import base64

bin = base64.b64decode(s)
with open('temp.zip', 'wb') as f:
    f.write(bin)

Once this is run, open the file up with your favorite zip-file opener and you get one file called IBM_DATA.txt with the contents:

Hello World!

I'd use base64. JSON isn't designed to communicate binary data. So unless your file's content is vanilla text, it "should be" encoded to use vanilla text. Virtually everything can encode and decode base64. If you instead use (for example) Python's repr(file_content), that also produces "plain text", but the receiving end would need to know how to decode the string escapes Python's repr() uses.

The docs confirm that your approach is ok.

base64.b64encode(byte_obj).decode('utf-8') is correct - base64.b64encode requires bytes as input:

Encode the bytes-like object s using Base64 and return the encoded bytes.

However base64.b64decode accepts bytes or an ascii string:

Decode the Base64 encoded bytes-like object or ASCII string s and return the decoded bytes.