The built-in JSON module can be used as a validator:

import json

def parse(text):
    try:
        return json.loads(text)
    except ValueError as e:
        print('invalid json: %s' % e)
        return None # or: raise

You can make it work with files by using:

with open(filename) as f:
    return json.load(f)

instead of json.loads and you can include the filename as well in the error message.

On Python 3.3.5, for {test: "foo"}, I get:

invalid json: Expecting property name enclosed in double quotes: line 1 column 2 (char 1)

and on 2.7.6:

invalid json: Expecting property name: line 1 column 2 (char 1)

This is because the correct json is {"test": "foo"}.

When handling the invalid files, it is best to not process them any further. You can build a skipped.txt file listing the files with the error, so they can be checked and fixed by hand.

If possible, you should check the site/program that generated the invalid json files, fix that and then re-generate the json file. Otherwise, you are going to keep having new files that are invalid JSON.

Failing that, you will need to write a custom json parser that fixes common errors. With that, you should be putting the original under source control (or archived), so you can see and check the differences that the automated tool fixes (as a sanity check). Ambiguous cases should be fixed by hand.

You can try to do json.loads(), which will throw a ValueError if the string you pass can't be decoded as JSON.

In general, the "Pythonic" philosophy for this kind of situation is called EAFP, for Easier to Ask for Forgiveness than Permission.

You can do something like this:

def convert(tup):                                                               
    """                                                                            
    Convert to python dict.                                                        
    """                                                                            
    try:                                                                           
        tup_json = json.loads(tup)                                                 
        return tup_json                                                            
    except ValueError, error:  # includes JSONDecodeError                          
        logger.error(error)                                                           
        return None 


converted = convert(<string_taht_neeeds_to_be_converted_to_json>):
if converted:    
    <do_your_logic>
else:
    <if_string_is_not_converteble>

You might consider jsonschema to validate your JSON. Here is a program that validates your example. To extend this to your "20 keys", add the key names to the "required" list.

import jsonschema
import json

schema = {
    "type": "object",
    "properties": {
        "customer": {
            "type": "object",
            "required": ["lastName", "firstName", "age"]}},
    "required": ["service", "customer"]
}

json_document = '''{
    "service" : "Some Service Name",
    "customer" : {
        "lastName" : "Kim",
        "firstName" : "Bingbong",
        "age" : "99"
    }
}'''

try:
    # Read in the JSON document
    datum = json.loads(json_document)
    # And validate the result
    jsonschema.validate(datum, schema)
except jsonschema.exceptions.ValidationError as e:
    print("well-formed but invalid JSON:", e)
except json.decoder.JSONDecodeError as e:
    print("poorly-formed text, not JSON:", e)

Resources:

• https://pypi.python.org/pypi/jsonschema
• http://json-schema.org/example1.html