ask_report_follow_up
ChatGPTSave a question about a completed report and queue an answer. Read the persistent thread with list_report_follow_ups.
Education & Research
Overview
Run exploratory research and evaluate concepts with AI-generated participants in your Synthetic Users workspace. Find projects, define audiences and studies, work with images and context documents, follow study progress, inspect interviews and insights, and download available exports. Connect an existing Synthetic Users account and choose a workspace. Access follows your workspace permissions and available entitlements. Synthetic user generation and interview runs require explicit confirmation. Create or regenerate reports when you need them. Available study types and features depend on the workspace. Interactive panels are available on hosts that support MCP Apps, with conversation or browser fallbacks where supported. Synthetic participants are AI simulations, not human research participants. Findings can inform hypotheses and research planning; they do not establish what real people will think or do.
Tools
ask_summary_follow_up
ChatGPTSave a question about a completed summary and queue its answer. Retrieve the persisted Q&A with list_summary_follow_ups.
attach_files_to_study
ChatGPTAttach context documents selected in open_context_files to an existing draft. Preserves other attachments; enforces the project's RAG budget and setup lock.
clone_study
ChatGPTClone study setup into a new draft. Copies quick audiences, goals and concepts, reuses standard audiences/files, and remaps concept references. Does not copy participants, interviews, results or reports, and does not spend credits.
complete_file_upload
ChatGPTFinish processing when the file bytes are already stored but still 'uploading'. The normal path is the POST to prepare_file_upload's upload.url, which stores the bytes and starts processing itself. Call this only to retry that step. Safe to retry: files that have left 'uploading' return their current status without processing again. read_file shows when the file is 'ready' for create_study.
confirm_interview_run
ChatGPTApp-only: start the exact interview run shown by the confirmation button. Requires its unexpired, single-use run token; uses interview credits.
create_audience
ChatGPTCreate a normal/free-text audience in this project. 'description' defines who the audience is; 'title' is an optional label (defaults to the description). Quick audiences support studies of up to 20 participants. create_crafted_audience creates an Audience Crafter (type="standard") audience with structured segments. generate_synthetic_users creates synthetic users from either kind.
create_crafted_audience
ChatGPTCreate a structured Audience Crafter audience (type="standard"). The description defines the audience. Optional attributes supply criteria, e.g. {"cities": ["New York state"], "age": [18, 80], "voting_eligibility": ["Eligible to vote in New York"]}. segment_by selects an attribute for grouping; "none" keeps one segment. The app's world model resolves geography, population estimates and research parameters in the background. read_audience reports crafting.status and the resulting segments. Once ready, create_study or edit_study(audience_ids) attaches this audience; generate_synthetic_users creates its participants separately. This preserves an existing study's questions and starts no interviews. Studies support up to 20 participants, or 50–300 with a custom script and large-study access; 21–49 participants are unsupported even with a crafted audience.
create_file_export
ChatGPTExport an output_id from list_export_options in one of its offered formats. Returns immediately with export_id/status; read_file_export reports progress, with retry_after_seconds between checks. Each call exports one file and format. 'include' selects PDF sections only (use pdf_parts from the catalog); omitted means all. Each report or summary version has its own output_id. idempotency_key is optional: the same key retries the same request, and a new key makes a fresh file (for a failed or outdated one). Exports use the existing platform renderers, without spending interview credits or regenerating report content. Clients that render MCP Apps show the export in a card with its progress and a Download button. When ready, read_file_export returns the filename and size with a signed download_url and its expiry, or a 'download' note where the card holds the link. One failed export doesn't affect the others.
create_monadic_concept_plan
ChatGPTCreate a monadic plan: one study per concept, so each participant sees only one concept. Uses a Quick Audience and copies it to isolate this plan's participant pool. Returns total_interviews = concepts × interviews_per_concept. Creates no synthetic users or interviews and uses no credits. prepare_monadic_concept_plan generates participants; run_monadic_concept_plan opens the interview confirmation. Each concept's optional image_id is its ready media (uses='concepts'): an image, a video or a PDF/PPTX/DOCX document.
create_project
ChatGPTCreate a project in this connection's authorized workspace. Requires an active workspace owner or admin. 'name' must not be blank; 'description' is optional. No project_id or workspace_id is needed: the workspace is fixed by the connection. Project-locked connections cannot create projects. This creates an empty research project and spends no credits. Returns {id, name, description, type, workspace_id, created_at}; pass the returned id as project_id when creating audiences and studies.
create_report
ChatGPTCreate a study's report: the graph-rich report shown in the app's Report tab (executive summary, thematic sections and rendered charts). Pass either study_id or study_ids (for a combined report, including a monadic plan's child study IDs from read_monadic_concept_plan). Every study must be in this project. Set generate_now=false to review/edit the outline before calling generate_report. table_of_contents supplies a custom outline. By default, creating the report also starts building it: right away when the study analysis is ready, otherwise by itself once the analysis is ready (this call kicks it). read_report shows its status until 'done', and clients that render MCP Apps also follow it in a Study run card. generate_report is only for regenerating or retrying. The study must have finished its interviews (status 'done') before a report can be created. 'focus' optionally steers the report (e.g. "pricing objections"). For downloadable reports and charts, use list_export_options(report_id=...), create_file_export, then read_file_export, which returns signed download links; the platform renders the charts. Returns the created report with 'generation': 'started' or 'deferred'.
create_research_goal
ChatGPTCreate a research goal in this project. 'description' states the questions/learning objectives. Returns the created goal.
create_study
ChatGPTCreate a study in this project; creating it runs nothing. Studies run up to 20 synthetic users; 'custom_script' also runs 50–300. study_type (default 'research_goal_interview'): • 'research_goal_interview' — a Q&A interview for questions you'd like answered: the AI interviewer works through the research goal (research_goal_id), asking and probing; no concept is shown. The app's Research Goal interview ('dynamic_interview' is also accepted). • 'ethnographic_research' — an interview by an ethnographer who asks like a field observer, also driven by research_goal_id: what someone does, their settings, people and artifacts, workarounds, where actions differ from words. Fits day/week in the life, shadowing, or field observation requests. • 'solution_feedback' — one solution_descriptions entry (a product or message) tested for problem–solution fit against problem_descriptions. To compare options, or with no specific pain, 'concept_study' applies. The app calls it "Concept Testing" (not a study_type). • 'concept_study' — reactions to named concepts in solution_descriptions: one, or alternatives for one decision (for example three landing pages) that each synthetic user reacts to in one interview. Fit with a named pain is 'solution_feedback'. Monadic tests (one concept per synthetic user) use create_monadic_concept_plan. • 'custom_script' — script_questions asked in order, in place of the AI interviewer. With a create_crafted_audience audience it runs 50–300 synthetic users: the app's Quantitative Testing (large-study access), for survey-style questions such as multiple choice or 1–7 scales. • 'task_simulation' — live-URL user testing (the app's "User testing"; 'user_testing' is also accepted): each synthetic user works through the tasks in one browser session. Returns the created study; 'strategy' is the stored type code, 'study_type_label' the app's name.
delete_audience
ChatGPTDelete your unused, unlocked audience. Fails while any study still uses it.
delete_research_goal
ChatGPTDelete an unused research goal. Fails while a study still uses it.
detach_files_from_study
ChatGPTDetach context documents from an existing draft without deleting their files.
edit_audience
ChatGPTEdit an unlocked audience's description/title, preserving its other configuration. Shared published/generated audiences are immutable. Change study associations with edit_study.
edit_research_goal
ChatGPTEdit a research goal while every study using it is still configurable.
edit_study
ChatGPTEdit an existing study. Description/bookmark remain editable after a run. Setup changes require an empty participant pool, as in the app. Use clone_study when setup is locked. Pass research_goal_id=null to remove the goal. Questions are preserved individually in the structured guide. No interview is rerun.
generate_report
ChatGPTRegenerate a report, or retry one that failed. Replaces its sections. create_report already starts generation; this is for a requested regeneration, or a report that failed or didn't start. It builds now when the study analysis is ready; otherwise it starts by itself once the analysis is ready ('generation': 'deferred') without another call. read_report shows status; once it is 'done', 'sections' hold the finished report. list_export_options(report_id=...) lists file downloads.
generate_study_knowledge_graph
ChatGPTBuild a graph from completed study evidence. Set rebuild=true to retry/rebuild an existing graph. Does not regenerate interviews. Monadic child studies use their interviews and combined reports instead of the graph pipeline.
generate_study_summary
ChatGPTGenerate a new saved summary from completed interview evidence, optionally with a focus such as pricing objections. read_summary shows it once done. Does not rerun interviews.
generate_synthetic_users
ChatGPTCreate
quantity synthetic users from a Quick or ready Audience Crafter audience. Creating synthetic users uses no interview credits; run_study_interviews bills the interviews. create_audience creates Quick audiences; create_crafted_audience creates structured audiences. Quick studies support up to 20 participants; crafted custom-script studies support 50–300 with large-study access. Counts of 21–49 are unsupported. With study_id, participants draw on its context files (create_study's rag_file_ids), which must have finished analyzing. Generating them locks the study's setup; clone_study copies it. Monadic plan studies use prepare_monadic_concept_plan, and studies whose interviews have started are rejected. Returns generated_synthetic_user_ids with status 'generating'; they become 'ready' in the background. wait_for_study_run(synthetic_user_ids=[these ids]) returns once they have, list_synthetic_users shows their status, and clients that render MCP Apps show a Study run card that updates itself. These synthetic users are available for review before run_study_interviews(synthetic_user_ids=[these ids]). This operation starts no interviews.get_project
ChatGPTReturn one project's context (id, name, description, type). Pass 'project_id' (from list_projects) on a workspace-scoped connection; everything else (audiences, studies, interviews, summaries) is then scoped to it.
get_study_report_toc
ChatGPTGet a study's canonical report outline, generating it if absent. Review the sections before creating a report; update_report customizes an individual report.
interview_follow_up
ChatGPTAsk a participant another question in a completed interview. Saves the question and queues an answer; read_interview retrieves the updated conversation. For a browser-testing session use task_simulation_follow_up with its simulation ID.
list_audiences
ChatGPTList the audiences (synthetic users) in this project. Output: {"audiences": [{id, title, description, type, status, created_at}]}. Use read_audience for full segments/attributes.
list_export_options
ChatGPTList every file a study or a standalone report can produce; takes exactly one of the two ids. Returns output_ids, formats, readiness, source ids and PDF section choices. Also returns recent export_ids so downloads can resume later. Reports: PDF/PPTX/CSV/XLSX/JSON/TXT; full studies: PDF; transcripts and annotations: TXT; video findings: PDF/CSV; charts/cards: PNG; graphs: PNG/SVG. Availability depends on the source. A report CSV and a video-verbatims CSV contain different data. A report that doesn't exist yet comes from create_report, and then appears here. Exports never rerun interviews. Multiple output_ids can be different versions of a report. This call is read-only: no export starts from it.
list_files
ChatGPTList uploaded files in this project (id, filename, uses, status, tokens). Filter by 'uses' — e.g. 'rag' for context documents, 'concepts' for concept images, videos and documents. Use this to check a file's processing 'status': it must be 'ready' before a study that attaches it can run (a freshly uploaded RAG file stays 'processing' for a while), and to discover ids of files uploaded through the connector or web app to pass to create_study.
list_monadic_concept_plans
ChatGPTList this project's monadic concept plans and their child studies.
list_projects
ChatGPTList the projects you can access in the bound workspace: ids and names. The entry point for a workspace-scoped (OAuth) connection: project tools take one of these ids as 'project_id'; create_project adds a new project. Returns {"projects": [{id, name}]}; audiences and other data are read inside a specific project. include_studies=true adds each project's studies in the same call, as {id, name, status, type, interviews, created}, newest first and at most 50 per project; 'studies_total' counts them all and list_studies has full rows. These results come in pages of about 40,000 characters with 'total', and 'next_offset' when more projects remain.
list_report_follow_ups
ChatGPTRead a report's saved question-and-answer thread in chronological order.
list_reports
ChatGPTList standalone reports in this project, optionally filtered by a study. Includes combined reports. read_report retrieves their body and current outline.
list_research_goals
ChatGPTList the research goals in this project. Output: {"research_goals": [{id, description, project_id, ...}]}.
list_studies
ChatGPTList the studies in this project. Output: {"studies": [{id, description, status, interview_count, strategy, ...}]}. Poll a study's 'status' to track a run started with run_study_interviews — it is the same status read_study reports. Each study carries 'study_type_label' — the study type as the app names it (e.g. "Research Goal Interview") — and 'strategy', the code the tools accept.
list_study_summaries
ChatGPTList all saved/generated summaries for a study. Use read_summary for full content.
list_summary_follow_ups
ChatGPTRead the saved question-and-answer thread for a summary, in chronological order.
list_synthetic_users
ChatGPTList the generated synthetic users in this project, with their 'status' ('generating' → 'ready'). Pass study_id for one study's participants, as the app shows them, or audience_id to filter to one audience. Deleted synthetic users, including ones whose generation failed, are left out, as in the app. Each ready synthetic user carries a short 'profile' (name, age, location, profession), so you can say who the participants are before any interview; read_synthetic_user returns one in full. Use this to confirm synthetic users are 'ready' before running — e.g. a 'task_simulation' study, or run_study_interviews(synthetic_user_ids=...).
open_context_files
ChatGPTOpen the interactive Context files panel in this conversation. For when the user wants synthetic users and interviews to draw on their own documents (research, reports, data). Uploads go into the project's files, with or without a study: a study created later takes them as create_study's rag_file_ids (that study_id then goes to generate_synthetic_users), and study_id adds them to an existing editable study. The user picks the original files in the panel, and the panel uploads them and shows analysis progress; their 'Use these files' message carries the verified file ids. A file already attached in a ChatGPT chat can go to prepare_file_upload's file input instead, with nothing to pick. Opening or using this panel does not create a study, generate synthetic users or spend credits. Clients that cannot render MCP Apps use prepare_file_upload(uses='rag') and its browser_upload_url instead.
open_study_image_upload
ChatGPTOpen the interactive Concept media panel in this conversation. For when the user wants to supply the media concepts show participants: images, videos, or PDF/PPTX/DOCX documents such as brochures (videos and documents where the account has them). The user selects the original files in the panel; no code execution, platform login or chat attachment transfer is needed. A video longer than 60 seconds gets a window of up to 60 seconds to analyse in the panel. Their 'Use these concepts' message carries the verified file ids and labels in order, matching create_study's concept_image_ids and solution_descriptions positions. Opening or using this panel does not create a study, generate synthetic users or spend credits. Pass study_id and solution_id to select replacement media for an existing draft concept; set_study_concept_image then applies the selected file ID. Clients that cannot render MCP Apps use prepare_file_upload, which returns a standalone browser_upload_url for each file. A file is uploaded once read_file shows it 'ready'.
prepare_context_file_upload
ChatGPTApp-only: prepare original document bytes; refresh a pending id on retry.
prepare_file_upload
ChatGPTUpload a user-provided file to this project's files, with or without a study. 'concepts' is the media a concept shows participants: PNG/JPEG/GIF/WebP images, MP4/MOV/WebM/AVI/MKV videos, or PDF/PPTX/DOCX documents such as a brochure, deck or one-pager (office files become PDFs). 'rag' is research context: PDF, Word, PowerPoint, Excel, CSV and OpenDocument documents. Audio is not supported. Concept documents are limited to the plan's page cap (50 pages by default). Size limits: 500 MB for videos, 75 MB for concept documents, 10 MB otherwise. The original bytes arrive one of three ways: 1. file: in ChatGPT, a file attached in this chat. The connector downloads it and returns the stored file, with no upload step after. 2. Without file, this returns a file id, upload.url (this API, never S3), upload.file_field, upload.max_bytes and browser_upload_url, valid for 15 minutes. A code/file environment that has the file and can reach upload.url (ChatGPT's code sandbox can't) sends a multipart POST with the binary in the 'file' field, no Authorization header and no other form fields. A 200 means the bytes are stored and processing has started, so complete_file_upload isn't needed. 3. browser_upload_url: a page where the user picks the same file in their browser, for environments that can't reach upload.url. read_file reports status: images are 'ready' at once, while videos and documents are 'processing' first. Once 'ready', the id goes to create_study as 'concept_image_ids' (concept media) or 'rag_file_ids' (context documents). Tool arguments can't carry file contents, and a file counts as uploaded only once read_file shows it. The connector cannot read a client-local path, or a chat attachment outside ChatGPT.
prepare_monadic_concept_plan
ChatGPTGenerate a monadic plan's participants for review, with no interviews or credit spend. Returns the same participant batch on repeated calls. wait_for_study_run with generated_synthetic_user_ids tracks readiness; run_monadic_concept_plan opens the plan's interview confirmation once they are ready.
prepare_study_image_upload
ChatGPTApp-only: prepare original concept media bytes; refresh a pending id on retry.
read_audience
ChatGPTRead an audience's segments and attributes. For create_crafted_audience, crafting.status is generating, ready or error (with an error explanation). A ready crafted audience supports generate_synthetic_users.
read_context_files
ChatGPTApp-only: analysis status and progress of the selected files, and the context space they use.
read_file
ChatGPTRead a single uploaded file's metadata and processing status.
read_file_export
ChatGPTPoll one export for progress, failure, or the finished file's filename, MIME type and size. Wait retry_after_seconds between polls. A ready response supplies a fresh signed download_url and its expiry, so an expired chat link can be renewed, or a 'download' note where the File export card holds the link. Jobs continue when chat stops; resume with the same export_id. This connector does not send unsolicited messages after a study finishes.
read_interview
ChatGPTRead the full transcript of a single interview (the conversation between the AI interviewer and the synthetic user). Use this to extract quotes and analyze what a participant actually said — discover interview ids via read_study_interviews. Set include_profile=true to also get that participant's profile (demographics, traits, backstory). Reading every full transcript in a study with more than 20 interviews can add substantial context. Total size also depends on interview length. read_study_insights provides synthesized findings when available. Output: an Interview object with 'conversations' (the messages), plus 'profile' when include_profile is set. Task-simulation sessions have no conversation turns; for those the transcript is returned as 'session_log' — the per-task interaction log (actions + think-aloud reasoning + outcomes) and answered follow-ups.
read_monadic_concept_plan
ChatGPTRead a monadic plan, child study IDs, per-concept counts and execution status.
read_report
ChatGPTRead a standalone report in full: status, table_of_contents, sections (the report body), focus, progress, and the ids of its studies. Use this to poll a report you created: it generates by itself once the study analysis is ready, so poll until 'status' is 'done'; the 'sections' then hold the finished report. Use list_export_options(report_id=...) to download the report or its charts.
read_research_goal
ChatGPTRead a single research goal in this project.
read_study
ChatGPTRead a study in full: status, audiences, research goal, scripts (guides), progress, and the ids of its interviews and summaries. 'strategy' is the stored study-type code, which for historical reasons can differ from the app's name for it ('dynamic_interview' is a Research Goal interview); 'study_type_label' is that name. 'study_type' parameters always accept the 'strategy' code, and most labels. Next steps from here: read_study_insights (synthesized findings), read_summary (a specific summary), read_interview (a single transcript). analysis_ready/analysis_status describe usable results; post_processing_status separately tracks background work. Analysis is saved automatically without a report.
read_study_analysis
ChatGPTRead cached study analysis: themes, sentiment, drivers, quotes and ranking, plus freshness/status. Analysis is saved automatically; no summary or report is required to save it. analysis_ready describes usable results, while post_processing_status tracks remaining background work. Does not trigger generation.
read_study_insights
ChatGPTReturn the synthesized findings for a study — its most recent summary (content + sections). This is the fastest way to "explain the insights" of a study without reading every transcript. Without a summary, returns the automatically saved study analysis (themes, sentiment, drivers and quotes). It is already persisted; creating a summary or report is not necessary to save it. analysis_ready and analysis_status describe its readiness; post_processing_status tracks other background work. If neither is available, read_study_interviews + read_interview provides raw transcripts. create_report creates a separate narrative report and starts generation automatically once the study analysis is ready.
read_study_interviews
ChatGPTList interview metadata for a study (status, ids, timestamps), without the transcripts; read_interview(interview_id) returns a transcript. Output: {"interviews": [{id, status, synthetic_user_id, ...}]}.
read_study_knowledge_graph
ChatGPTRead a study's knowledge graph and generation status, including its graph data.
read_study_run
ChatGPTApp-only: progress of a study's synthetic users, interviews, analysis and report.
read_study_task_simulations
ChatGPTList a study's user-testing sessions: tasks, participants, status, observations and recording links. Use read_task_simulation for steps, screenshots and follow-ups.
read_summary
ChatGPTRead a specific summary by id (content + sections + linked study).
read_synthetic_user
ChatGPTRead one generated synthetic user in full, as the app's participant card shows it: 'personal_information' (name, age, location, profession), 'personality_traits', 'miscellaneous' (the audience's attributes), 'backstory' and the raw 'description'. Find ids with list_synthetic_users.
read_task_simulation
ChatGPTRead a user-testing session's ordered actions, reasoning, screenshots, video timestamps, observations and persisted follow-up answers. Also polls pending answers.
regenerate_study_post_processing
ChatGPTRebuild analysis and annotations from existing interviews, for example after follow-ups. The worker deduplicates concurrent analysis runs. No interviews run.
run_monadic_concept_plan
ChatGPTOpen confirmation for a prepared monadic plan's entire interview run. Shows its ready participants, concepts, total interview count and credit cost. Starts no interviews; the card's Run button or signed-in confirmation_url does. confirm=true prepares this confirmation; it cannot start interviews. A new confirmation replaces the plan's earlier unused one.
run_study_interviews
ChatGPTPrepare a confirmation card for interviews with ready synthetic_user_ids. Starts no interviews. The card shows the study, participants and credit cost; its Run button starts that exact run. confirmation_url is the signed-in web fallback. confirm=true prepares the card; it cannot start interviews. A new confirmation replaces the study's earlier unused one. If every selected participant already has an interview in this study, returns the existing run's progress without another confirmation or charge. The legacy quantity shortcut is rejected; generate_synthetic_users creates participants separately. Includes user-testing browser sessions, except for sites behind a sign-in, which run from the Synthetic Users app. Monadic plans use run_monadic_concept_plan.
set_study_concept_image
ChatGPTReplace a draft study concept's media using a verified panel file ID; null clears it. The file can be an image, a video or a PDF/PPTX/DOCX document, and has to be 'ready'. Isolates a shared concept before editing and updates guide bindings and attachments.
task_simulation_follow_up
ChatGPTAsk a simulated participant about a completed browser session or specific step. Persists the question and queues its answer; read_task_simulation retrieves it. Does not reset or rerun the interview/browser session.
update_report
ChatGPTChange a report's outline while it is idle. Saved sections remain until the user requests generate_report; updating the outline alone does not rebuild it.
use_context_files
ChatGPTApp-only: verify files for a new study or attachment to an existing draft.
use_study_images
ChatGPTApp-only: verify the selected ordered concept media before adding them to the conversation.
wait_for_study_run
ChatGPTWait up to 25 seconds for a study run to settle, then return its progress. Requires study_id or synthetic_user_ids (or both). project_id alone only selects the project and cannot identify which run to follow. Follows the synthetic users from generate_synthetic_users (synthetic_user_ids) until each is ready or failed, and a study's interviews (study_id) along with the analysis that runs after them. Returns as soon as nothing is left to wait for, with 'done' true and the ready synthetic user ids. Otherwise it returns after 25 seconds with 'done' false, 'waiting_on' naming the stage still running ("synthetic_users", "interviews" or "analysis"), and counts of how far it got. That response is a snapshot, not a completion notification. Repeated calls continue observing an unfinished run without starting work or using credits. The live Study run card refreshes separately while open; chat text is static. 'stalled' is true once that stage has run far longer than usual (20 minutes for synthetic users, 90 for interviews and analysis). 'done' describes the stage being followed, not permission to start another. 'awaiting_interview_confirmation' marks ready participants awaiting review and the confirmation button; this read never starts interviews. 'confirmation_pending' is true while a confirmation card prepared for this study is still unused. 'interviews_started' describes the study; 'selected_interviews_started' is null unless both a study and participant ids were supplied. Analysis ready means the results are usable; post_processing_status separately tracks remaining background work. Reports are separate from automatically saved analysis.
Capabilities
WritesInteractive
Example Prompts
Click any prompt to copy it.
Links
App Stats
72
Tools
3
Prompts
ChatGPT
Platforms
Category
Company OperationsWorks with
ChatGPT
Data refreshed daily