If you want to dump the JSON into a file/socket or whatever, then you should go with dump(). If you only need it as a string (for printing, parsing or whatever) then use dumps() (dump string)

As mentioned by Antti Haapala in this answer, there are some minor differences on the ensure_ascii behaviour. This is mostly due to how the underlying write() function works, being that it operates on chunks rather than the whole string. Check his answer for more details on that.

json.dump()

Serialize obj as a JSON formatted stream to fp (a .write()-supporting file-like object

If ensure_ascii is False, some chunks written to fp may be unicode instances

json.dumps()

Serialize obj to a JSON formatted str

If ensure_ascii is False, the result may contain non-ASCII characters and the return value may be a unicode instance

There's a parameter called indent. It is None by default, which means "no pretty printing". If you set it to an integer value, it will enable pretty-printing, and use that many spaces to indent nested elements.

In your case it will be something along the lines of:

json.dumps(links, outfile, indent=4)

(or indent=2 if you prefer less spaces). Here's an example from the docs (link), which shows more functionality you might also want as you progress:

>>> import json
>>> print json.dumps({'4': 5, '6': 7}, sort_keys=True,
...                  indent=4, separators=(',', ': '))
{
    "4": 5,
    "6": 7
}

Here's a hack which converts everything to lists and then changes square brackets to curly ones. If your strings might contain square brackets that'll be a problem.

import json

inp = """
{
    "aaa": {
        "bbb": {
            "ccc": {
                "ddd": "string1",
                "eee": "string2"
            }
        },
        "kkk": "string3"
    }
}
"""

inp = json.loads(inp)


def items(d):
    if isinstance(d, dict):
        return [(k, items(v)) for k, v in d.items()]
    return d


inp = items(inp)

print(json.dumps(inp, indent=2).replace("[", "{").replace("]", "}"))

Output:

{
  {
    "aaa",
    {
      {
        "bbb",
        {
          {
            "ccc",
            {
              {
                "ddd",
                "string1"
              },
              {
                "eee",
                "string2"
              }
            }
          }
        }
      },
      {
        "kkk",
        "string3"
      }
    }
  }
}

You don't dump a string but to a string.

d = {"foo": "bar"}
j = json.dumps(d)
print(j)

Output:

{"foo": "bar"}

It makes no sense to use a string as the argument of json.dumps which is expecting a dictionary or a list/tuple as the argument.

Serialize obj to a JSON formatted str using this conversion table.

Dumping JSON directly (json.dump) writes the serialized output to the file "on the fly", as it is created. On the other hand, dumping to a string (json.dumps) and then writing the string to a file happens sequentially, so nothing is written to the file until the whole object is serialized in memory.

In practice, this makes very little difference for reasonably sized JSONs. Unless your JSONs are at least several megabytes and you care about the performance, use whatever makes the code cleaner.

dumps takes an object and produces a string:

>>> a = {'foo': 3}
>>> json.dumps(a)
'{"foo": 3}'

load would take a file-like object, read the data from that object, and use that string to create an object:

with open('file.json') as fh:
    a = json.load(fh)

Note that dump and load convert between files and objects, while dumps and loads convert between strings and objects. You can think of the s-less functions as wrappers around the s functions:

def dump(obj, fh):
    fh.write(dumps(obj))

def load(fh):
    return loads(fh.read())