If you load in the entire json as a dict (or list) e.g. using json.load, you can use json_normalize:

In [11]: d = {"response": {"body": {"contact": {"email": "mr@abc.com", "mobile_number": "0123456789"}, "personal": {"last_name": "Muster", "gender": "m", "first_name": "Max", "dob": "1985-12-23", "family_status": "single", "title": "Dr."}, "customer": {"verified": "true", "customer_id": "1234567"}}, "token": "dsfgf", "version": "1.1"}}

In [12]: df = pd.json_normalize(d)

In [13]: df.columns = df.columns.map(lambda x: x.split(".")[-1])

In [14]: df
Out[14]:
        email mobile_number customer_id verified         dob family_status first_name gender last_name title  token version
0  mr@abc.com    0123456789     1234567     true  1985-12-23        single        Max      m    Muster   Dr.  dsfgf     1.1

Use concat with dictionary comprehension:

df = pd.concat({k: pd.DataFrame(v) for k, v in j.items()})
print (df)
          ball_limit balls batted batting_team_id bowling_team_id bpo byes  \
1164223 0        300   300      1            2591            1832   6    1   
        1        300   294      1            1832            2591   6    0   
1165045 0        300   271      1            1003            2989   6    0   
        1        300   239      1            2989            1003   6    0   

          event      event_name extras  ...  overs overs_docked penalties  \
1164223 0     0            None     11  ...   50.0            0         0   
        1     0            None     10  ...   49.0            0         0   
1165045 0     1         all out     10  ...   45.1            0         0   
        1     3  target reached     12  ...   39.5            0         0   

          penalties_field_end penalties_field_start run_rate runs target  \
1164223 0                   0                     0     6.16  308      0   
        1                   0                     0     6.34  311    309   
1165045 0                   0                     0     3.74  169      0   
        1                   0                     0     4.26  170    170   

          wickets wides  
1164223 0       6     6  
        1       6     8  
1165045 0      10     5  
        1       3     6  

[4 rows x 32 columns]

Another solution is loop in dict comprehension and add key of outer dicts for list of dicts, last pass to DataFrame contructor:

df = pd.DataFrame([dict(x, **{'_id':k}) for k, v in j.items() for x in v])
print (df)
       _id ball_limit balls batted batting_team_id bowling_team_id bpo byes  \
0  1164223        300   300      1            2591            1832   6    1   
1  1164223        300   294      1            1832            2591   6    0   
2  1165045        300   271      1            1003            2989   6    0   
3  1165045        300   239      1            2989            1003   6    0   

  event      event_name  ...  overs overs_docked penalties  \
0     0            None  ...   50.0            0         0   
1     0            None  ...   49.0            0         0   
2     1         all out  ...   45.1            0         0   
3     3  target reached  ...   39.5            0         0   

  penalties_field_end penalties_field_start run_rate runs target wickets wides  
0                   0                     0     6.16  308      0       6     6  
1                   0                     0     6.34  311    309       6     8  
2                   0                     0     3.74  169      0      10     5  
3                   0                     0     4.26  170    170       3     6  

[4 rows x 33 columns]

It's simpler if you reformat the dictionary in Python first before constructing the DataFrame. Since you want the Sub keys, you can simply extract them using a list comprehension:

out = pd.DataFrame([v['Offer'] for v in my_data['response']['data'].values() if isinstance(v, dict)])

Output:

  sub1 sub2      sub3     sub4                                 sub5             sub6     sub7    sub8  sub9 sub10 sub11 sub12  sub13
0  231  626  XXXXXXXX  XXXXXXX   https://play.google.com/store/apps    https://XXXXX     0.39  active  None     0     0     1  XXXXX
1  216  626  XXXXXXXX   682666  https://play.google.com/store/appsg  https://XXXXXXX  1.96000  active  None     0     0     1  XXXXX

This function recursively calls itself to flatten dictionaries and lists.

from collections import OrderedDict

def flatten(json_object, container=None, name=''):
    if container is None:
        container = OrderedDict()
    if isinstance(json_object, dict):
        for key in json_object:
            flatten(json_object[key], container=container, name=name + key + '_')
    elif isinstance(json_object, list):
        for n, item in enumerate(json_object, 1):
            flatten(item, container=container, name=name + str(n) + '_')
    else:
        container[str(name[:-1])] = str(json_object)
    return container

Examples:

flatten([1, 2, 3])
OrderedDict([('1', '1'), ('2', '2'), ('3', '3')])

flatten([1, 2, 3], name='x')
OrderedDict([('x1', '1'), ('x2', '2'), ('x3', '3')])

flatten({'a': [1, 2, 3], 'b': 4, 'c': {'d': [5, 6], 'e': 7}}, name='x')
OrderedDict([('xa_1', '1'),
             ('xa_2', '2'),
             ('xa_3', '3'),
             ('xc_e', '7'),
             ('xc_d_1', '5'),
             ('xc_d_2', '6'),
             ('xb', '4')])

Response:

# j = json string
>>> pd.DataFrame(flatten(j), index=[0]).T
                                                      0
perMinuteLimit                                       10
distance                                             10
perMonthCurrent                                       0
longitude                                     35.751607
perMonthLimit                                      2000
latitude                                      -6.162959
perMinuteCurrent                                      0
networkRank_1_networkId                            6402
networkRank_1_type3G_sampleSizeSpeed                 29
networkRank_1_type3G_averageRssiAsu        9.5429091136
networkRank_1_type3G_pingTime                  320.9600
networkRank_1_type3G_networkType                      3
networkRank_1_type3G_averageRssiDb    -69.5664329624972
networkRank_1_type3G_networkName                Vodacom
networkRank_1_type3G_networkId                     6402
networkRank_1_type3G_downloadSpeed            1508.1304
networkRank_1_type3G_uploadSpeed               893.7692
networkRank_1_type3G_reliability      0.804236452826138
networkRank_1_type3G_sampleSizeRSSI                 948
networkRank_1_networkName                       Vodacom
networkRank_2_networkId                            6400
networkRank_2_type3G_sampleSizeSpeed                 21
networkRank_2_type3G_averageRssiAsu       15.3537142857
networkRank_2_type3G_pingTime                  259.0000
networkRank_2_type3G_networkType                      3
networkRank_2_type3G_averageRssiDb    -61.4563389583101
networkRank_2_type3G_networkName                   tiGO
networkRank_2_type3G_networkId                     6400
networkRank_2_type3G_downloadSpeed             516.0000
networkRank_2_type3G_uploadSpeed               320.4211
networkRank_2_type3G_reliability      0.911904765537807
networkRank_2_type3G_sampleSizeRSSI                 935
networkRank_2_networkName                          tiGO
networkRank_3_networkId                            6403
networkRank_3_type3G_sampleSizeSpeed                 21
networkRank_3_type3G_averageRssiAsu       13.2729999375
networkRank_3_type3G_pingTime                  194.5556
networkRank_3_type3G_networkType                      3
networkRank_3_type3G_averageRssiDb    -58.1521092977699
networkRank_3_type3G_networkName                 Airtel
networkRank_3_type3G_networkId                     6403
networkRank_3_type3G_downloadSpeed            1080.2500
networkRank_3_type3G_uploadSpeed               572.1579
networkRank_3_type3G_reliability      0.554680264185345
networkRank_3_type3G_sampleSizeRSSI                 587
networkRank_3_networkName                        Airtel
network_type                                       None
apiVersion                                            2

From my experience, pandas doesn't have a good way to handle lists in dicts in lists too well. But you can handle just lists in dicts using the record_path argument in json_normalize. So, this is not pretty, & a rather brittle way of solving the problem... but here's a solution:

data = # That mess
frames = []

for entry in data:
    frame = json_normalize(
        data[0]['a'], 
        record_path=('result'), 
        record_prefix='a.result.', 
        meta=['b', 'c'], 
        meta_prefix='a.'
    )

    frame['Id'] = entry['Id']
    frame['col'] = entry['col']
    frames.append(frame)

frame = pd.concat(frames)

Output:

  a.result.1 a.result.3  a.result.5  a.b  a.c  Id  col
0          2          4         6.0    1   ok  d0   16
1         21         41        61.0   11  ok1  d0   16
2        211        411         NaN   11  ok1  d0   16