Addition

[jeroenvermunt]

Are we interested in a method which pulls responses in the format below.

{
 'question name':'answer'
}

This seems a lot easier for developing with the typeform responses in the backend.

[henrihapponen]

I'd also like to see this feature, or something like an option to pull response answers directly as a Pandas data frame or a list of dictionaries.
It would still have question id's as column names but then you could just provide a dictionary that maps each question id to some column name that describes the question.

[jeroenvermunt]

Not quite a full feature yet but I wrote a function which maps question names and answers to ids, I use it for myself and could maybe be useful as a start:

def show_question_names(forms, form_id):
 '''show all question with the corresponding id, also shows the answers of multiple choice questions'''
 question_dict = {}
 
 form = forms.get(form_id)
 
 for field in form['fields']:
 
 # store id and question
 question_dict[field['id']] = field['title']
 
 # store answers of multiple choice questions
 if field['type'] == 'multiple_choice':
 question_dict[field['id'] + f'_choices'] = []
 for i, choice in enumerate(field['properties']['choices']):
 question_dict[field['id'] + f'_choices'].append({choice['id']:choice['label']})
 
 # store answers of questions belonging to a group
 if field['type'] == 'group':
 question_dict[field['id'] + f'_sub_questions'] = []
 for i, sub_question in enumerate(field['properties']['fields']):
 question_dict[field['id'] + f'_sub_questions'].append({sub_question['id']:sub_question['title']})
 
 pprint(question_dict)

[henrihapponen]

Looks good @jeroenvermunt !
I had to make something similar myself. My use case is to pull responses with multiple fields (30-100) periodically and append to a table in a data base. This function does the job of getting the response answers as a data frame (though I can't promise it's perfect):

def get_response_answers_df(form_uid: str, field_id_map: Dict, target_fields: List[str],
 since: int, until: int):
 """
 Get response answers as a Pandas Data Frame. Note that page size is 1000 (maximum).
 Args:
 form_uid (str): The form uid of the Typeform form to get metadata for.
 field_id_map (dict): The field-id map of the forms fields. So mapping id's to new field names.
 target_fields (list): The fields in the target table.
 since (int): Days (in integers) to get responses since.
 until (int): Days (in integers) to get responses until.
 Returns:
 df (Data Frame): The response answers as a Data Frame.
 """

 responses = typeform.responses.list(uid=form_uid, since=since, until=until, pageSize=1000)
 df_response_items = pd.json_normalize(responses['items'])
 df = df_response_items['answers']
 df = pd.json_normalize(df)

 response_ids = df_response_items['response_id'].tolist()
 landed_at_list = df_response_items['landed_at'].tolist()
 submitted_at_list = df_response_items['submitted_at'].tolist()

 # Rename columns to make them numbered
 for i in range(0, len(df.columns)):
 df.rename(columns={i: f'answer{i+1}'}, inplace=True)

 # Parse answers from nested structure to a flat table
 new_table = []

 for index, row in df.iterrows():
 row_dict = {}
 for i in range(1, len(df.columns) + 1):
 if row[f'answer{i}'] is not None:
 field_type = row[f'answer{i}']['type']

 try:
 field_id = row[f'answer{i}']['field.id']

 if field_type == 'choice':
 # If single-option choice
 try:
 row_dict[field_id] = row[f'answer{i}']['choice.label']
 except KeyError:
 row_dict[field_id] = row[f'answer{i}']['choice.other']
 elif field_type == 'choices':
 # If multiple-option choice
 try:
 row_dict[field_id] = ';'.join(row[f'answer{i}']['choices.labels'])
 except KeyError:
 row_dict[field_id] = row[f'answer{i}']['choices.other']
 else:
 # In other cases, the response value should match the field id
 row_dict[field_id] = row[f'answer{i}'][field_type]
 except KeyError:
 pass
 else:
 pass

 new_table.append(row_dict)

 # Re-assign df to new table
 df = pd.DataFrame(new_table)

 # For target columns that have an id but don't exist in this response pull, add empty values
 for column in field_id_map.keys():
 if column not in df.columns:
 df[column] = ''

 # Then rename all columns
 df.rename(columns=field_id_map, inplace=True)

 # Add response_id (name as typeform_id) and submitted_at as columns
 df['typeform_id'] = response_ids
 df['form_start_datetime'] = landed_at_list
 df['form_submit_datetime'] = submitted_at_list

 # Then for all target columns that don't exist in this response pull, add empty values
 for column in target_fields:
 if column not in df.columns:
 df[column] = ''

 # Re-order columns according to target_fields (and add any field_id_map fields that are not in target fields)
 all_fields = target_fields + list(set(field_id_map.values()) - set(target_fields))
 df = df[all_fields]

 # Add potential hidden fields
 hidden_fields = []
 for field in df_response_items.columns:
 if 'hidden.' in field:
 hidden_fields.append(field)

 df_hidden_fields = df_response_items[hidden_fields]
 df = pd.concat([df, df_hidden_fields], axis=1)

 return df