- Brand
- Episto
- Category
- Data & Analytics
- Primary Subcategory
- Audience & Market Research
Integration details
Description
Episto is a market research platform for running surveys and AI-moderated interviews. This plugin connects ChatGPT to your Episto account so you can analyze survey results and manage your studies in plain language. Every action runs with your own Episto permissions. With Episto in ChatGPT you can: - Read survey results: aggregated answers per question, cross-tabulated by segment, and individual responses. - See where participants screen out or drop out of a questionnaire. - Follow fieldwork: number of completes against targets and quotas. - List your surveys and see the questions they contain. - Build or edit a questionnaire: sections, questions, standard question blocks and recodes. - Create dashboards and add result cards to them. - On AI-moderated interview studies, create analysis grids and ask a question answered for every respondent or every population. - Read and reply to the review comments left on a questionnaire. You need an existing Episto account to connect.
- Integration type
- Plugin
- Verification status
- Not applicable
- Platform
- ChatGPT
- Primary Subcategory
- Audience & Market Research
- Secondary Subcategories
- None listed
- Brand
- Episto
- Access
- Account required
- First tracked
- 2026-11-20
- Tool count
- 64
- Market
- US
The Primary Subcategory used for this profile’s headline score.
Other Subcategories where the Integration is listed.
Not discoverable in ChatGPT yet
ChatGPT now suggests Plugins on its own when they match a user's request, but not every Plugin is being surfaced yet.We haven’t seen Episto suggested yet. Sign up and we’ll track it, and your Discoverability Score will appear here once ChatGPT starts surfacing it.
What discovery looks like

Get alerts for Episto
Get updates when Episto’s Discoverability Score or category rank changes.
Competing in ChatGPT Audience & Market Research
View Category64 tools agents can invoke
Add one card to a results dashboard. Four card types: "question" and "recode" chart a question and require card_id (the card_id of the question in get_results_map); "content" is an editorial block and needs content.sub_type set to "section" (a title splitting the dashboard, its wording in content.title) or "text" (a comment, its wording in content.text); "analysis" is a computed block (crosstab, KPI, funnel, TURF, key drivers, map, word cloud…) whose content.sub_type names the analysis — pick it with list_analysis_card_types and fill content and options exactly as describe_analysis_card_type says, with question ids and answer codes from get_results_map; a card whose ids are wrong renders empty. insert_at is 1-based and pushes the cards below it down, so you can place a card without renumbering the rest; omit it to append at the end. Read get_dashboard first to know the current positions.
add_dashboard_card
Insert a new card (question, message or operation) in the questionnaire. `type` is a card type string (q_single, q_multiple, q_open, q_nps, q_rating, m_text…). `specs` carries the type-specific fields — call describe_card_type for the fields the type expects; localized texts are keyed by the survey locale tokens. Elements of a collection (answers, items, images…) get a generated `token` when you omit it — supply one only to give it a readable identifier you reference in the same call. previous_card_token positions the card right after that one; omit it to append at the end, or pass position 'first' to insert at the top (of section_token, else of the questionnaire). Every card belongs to a section: pass section_token (from list_sections) to choose it, otherwise the new card joins the section of previous_card_token (the first section by default) — use move_card to change it. The platform validates the card and answers 422 with the validation messages — fix the specs and retry, nothing is persisted while errors remain.
create_card
Insert a new section in the questionnaire. previous_section_token positions it right after that section; omit it to append at the end. The new section starts empty — move existing cards into it with move_card, or create new ones with create_card using a previous_card_token inside it.
create_section
Add a text the user gave in the conversation (brief, kick-off notes, previous results, an email) as a source of the survey context. It is not written into the context itself: call generate_survey_context afterwards to have Episto AI use it. For files on the user’s machine, use create_context_upload_link instead. 50 sources at most per survey.
add_survey_context_text
Insert several cards in one call, and the sections holding them when they are new: a whole questionnaire or a block of questions, where create_card adds one card. Each card takes the `type`, `name` and `specs` of create_card (list_card_types for the types, describe_card_type for the specs each type expects). `sections` creates new sections with their cards, each placed after previous_section_token or after the previous section of the call (the end of the questionnaire by default); `cards` adds cards to existing sections with the placement options of create_card, a card without them following the previous card of the call, sections included (the end of the questionnaire for the first). Both lists can be combined; sections are created first, then cards, in the order given. Give a card a `token` to reference it in a condition of a later card of the same call (conditions[].card_token), as for answers; a condition can only reference a card already in the survey or earlier in the call. All or nothing: the platform validates every card and answers 422 with the messages per card (sections[i].cards[j], cards[k]) — fix them and send the whole call again, nothing is persisted while errors remain.
create_cards
Adds one AI question column per prompt to a grid: each question is answered from the interviews, once per row — per respondent on a respondent grid, over the whole population on a population grid, where a comparative summary is generated on top. The answers are produced in the background: the tool returns each column id and its number of `pending` cells, then call get_grid until each one is `done` or `failed`. One generation runs per row, so a question costs as many model calls as the grid has rows — on `default`, one per respondent of the survey.
ask_grid_question
Have Episto AI read a whole source of the survey context (pasted text, PDF, Office or OpenDocument file, spreadsheet, text, image or mail) and answer one precise question from it: figures, quotes, a table, what a slide shows. Use it when the context and its "Sources" map are not enough. A source describes the study, it is not what respondents answered. It can take a few minutes: ask everything you need from a source in one question. Source tokens come from get_survey_context.
ask_survey_context_source
Renames a grid, adds or removes its rows and columns, and reorders them; answers are never generated here (use ask_grid_question). Rows: `add_respondent_ids` (the `respondent_id` of get_individual_data) and/or `add_population_tokens` (from list_populations: the population itself on a population grid, its respondents on a respondent grid). Columns: `add_question_ids` (question ids from list_survey_questions, respondent grids only). Removing takes the row and column ids of get_grid, and deletes the answers they hold; reordering takes every id in the wanted order. The AI questions a grid already asks are answered for every new row, one model call each. The default "All respondents" grid cannot be renamed and holds every respondent: row changes are refused on it.
update_grid
Walk the questionnaire with fake respondents to find what will not work before going live. The platform creates or refreshes coverage profiles from the programming — one completing the survey, one per target, one per screen-out, one per answer a display condition depends on, plus random respondents — then regenerates the respondents of every active fake respondent profile of the survey, the ones created by hand included. The survey must be in draft or review status. The answer waits up to a minute for the report (read it as described in get_programming_check); when `status` is still "running", call get_programming_check a bit later.
run_programming_check
Codify free text into categories: the AI reads every verbatim of an open question — or every AI Chat interview — and assigns each respondent to the categories you define. This is how a qualitative question becomes analysable alongside the closed ones. Read the verbatims first with get_individual_data to decide the categories, then name them here; the AI matches the text against them following ai_instruction. Call get_results_map for the source card token. Codifications are analysis recodes by nature: they run on collected text, so they default to the analysis origin whatever the survey status. The answers of an analysis recode are computed asynchronously after the card is created, so re-read the survey a moment later to see them; a programming recode is computed as each respondent passes. The response states the origin retained and where the recode is visible — repeat it to the user. Nothing is persisted while the card is invalid: the platform answers with the validation messages, so fix them and retry.
create_codification_recode
Create a recode whose categories are defined by conditions across several questions, rather than by one source question — segments like "urban parents" or "detractors who also cancelled". Mode 'single' assigns each respondent to the first category whose conditions match, 'multiple' to every category that matches. Call get_survey_map first: conditions reference a card by its token and its answers by their `token` (not their code). A matrix is targeted item by item: send its card_token plus the item_token. A respondent attribute is read by name with card_token '__user_attribute__' plus attribute_name. The top 1 of a ranking is read with card_token '<ranking token>_top_1' and the ranking's answer tokens. Only send card_token, type, values and operator — the platform derives the rest. The answers of an analysis recode are computed asynchronously after the card is created, so re-read the survey a moment later to see them; a programming recode is computed as each respondent passes. The response states the origin retained and where the recode is visible — repeat it to the user. Nothing is persisted while the card is invalid: the platform answers with the validation messages, so fix them and retry.
create_conditions_recode
Turn a URL parameter carried by the survey link into an analysable question — the usual way to split results by traffic source, wave, store or any tag passed at recruitment. Give categories to group the raw values (each with the exact values it absorbs), or omit them entirely to keep the parameter verbatim as an open question. The answers of an analysis recode are computed asynchronously after the card is created, so re-read the survey a moment later to see them; a programming recode is computed as each respondent passes. The response states the origin retained and where the recode is visible — repeat it to the user. Nothing is persisted while the card is invalid: the platform answers with the validation messages, so fix them and retry.
create_url_parameter_recode
Turn an attribute carried by the mailing list contacts into an analysable question — loyalty tier, region, subscription plan, anything the client sent along with the email addresses. Call list_contact_attributes first for the available names: an attribute holding free text is kept verbatim, while one with known values can be grouped through categories. The tool picks the right transformation from the attribute itself, so you only choose the grouping. The answers of an analysis recode are computed asynchronously after the card is created, so re-read the survey a moment later to see them; a programming recode is computed as each respondent passes. The response states the origin retained and where the recode is visible — repeat it to the user. Nothing is persisted while the card is invalid: the platform answers with the validation messages, so fix them and retry.
create_contact_attribute_recode
Create a new, empty results dashboard on a survey and return its token. Fill it afterwards with add_dashboard_card. To build a dashboard from scratch, read get_results_map first: it lists the questions and their card_id, which is what the cards refer to.
create_dashboard
Saves a population on a survey, as the dashboards do: a name and filters in the dashboards format, `{ "<question id>": { "<answer code>": true } }` (question ids and codes from list_survey_questions). When a population with the same filters already exists, it is returned instead with `existing: true`.
create_population
Create a survey owned by the user, with the same attributes as the platform API. The draft is initialised from the default template: its sections and default message cards (welcome, thanks…) are cloned, so the survey is never empty — inspect it with get_survey_map and list_sections before building the questionnaire with create_section and create_card. Every card belongs to a section. The questionnaire is never generated for you: write its cards yourself.
create_survey
Creates a grid on an AI Chat study and returns it with the link to the Grids page. A `respondent` grid compares respondents one by one (`respondent_ids`, the `respondent_id` of get_individual_data, and/or every respondent of `population_tokens`); a `population` grid compares saved populations (`population_tokens`, from list_populations) and gets a comparative summary. Then ask a question with ask_grid_question. To question every respondent at once, skip this and use the `default` grid.
create_grid
Mint a short-lived pre-authorized URL that hosts images for the questions of a survey: image-choice answers, ranking answers (display_answer_images) and matrix items (display_item_images). This is THE way to bring images from the user’s machine: bytes must never travel through the conversation, so the link carries the upload instead. One plain multipart POST per image (or several "file" fields in one POST), no auth header — the link itself is the authorization. The POST response lists { file, url } for each hosted image; nothing is attached to a card yet. Use the link like this: (1) if you can run shell commands on the machine holding the images, curl them — curl -sS -F "file=@/path/photo.png" "<upload_url>" — and read the urls from the response; (2) otherwise give the user the link to open: it is a drag-and-drop page that shows the url of each uploaded image, ask the user to paste them back. Never read the files yourself to re-send them. Then write each url into the `url` of its answer or item with create_card / update_card, keyed by locale like the element `title` (describe_card_type). An image already reachable at a public URL needs no upload. Images only (jpg, jpeg, png, webp, avif, gif), 30 MB max each, link valid 2 hours. Needs edit rights on the survey.
create_card_image_upload_link
Mint a short-lived pre-authorized URL that receives files as sources of a survey context (briefs, kick-off notes, previous results, decks). This is THE way to bring files from the user’s machine: bytes must never travel through the conversation, so the link carries the upload instead. One plain multipart POST per file (or several "file" fields in one POST), no auth header — the link itself is the authorization. Each accepted file becomes a source of the survey; the POST response lists them. Use the link like this: (1) if you can run shell commands on the machine holding the files, curl them — curl -sS -F "file=@/path/brief.pdf" -F "file=@/path/notes.docx" "<upload_url>"; (2) otherwise give the user the link to open: it is a drag-and-drop page in the browser. Never read the files yourself to re-send them. PDF, Office, OpenDocument, images, text and mail files only (.pdf, .doc, .docx, .ppt, .pptx, .odt, .odp, .rtf, .xls, .xlsx, .ods, .csv, .tsv, .png, .jpg, .jpeg, .webp, .gif, .heic, .tif, .tiff, .txt, .md, .markdown, .html, .htm, .xml, .json, .eml, .msg), 50 MB max each: any other type is refused, including archives (unzip them and send their files) and binaries such as SPSS files; 50 sources at most per survey; link valid 2 hours. Uploading does not rewrite the context: call generate_survey_context once the files are in.
create_context_upload_link
Remove a card from the questionnaire, along with its questions. The platform refuses when the card is a recode used by the weighting setup (the error explains it). Deletion is immediate and not reversible — double-check the card_token against get_survey_map before calling.
delete_card
Remove a section from the questionnaire. Its cards are not deleted: they are reassigned to the previous section. The platform refuses to delete the first section.
delete_section
Delete one source (uploaded file or pasted text) of the survey context; the file itself is deleted too. The context text is left as is: call generate_survey_context to rewrite it without that source. Source tokens come from get_survey_context.
delete_survey_context_source
Deletes a grid with its rows, its columns and every answer they hold — not reversible, double-check the grid token first. The default "All respondents" grid cannot be deleted.
delete_grid
Return the fields an analysis card reads, split between `content` (what it computes on: question ids, answer codes, settings) and `options` (how it is displayed: population, heading, color, width), with the eligible question types, the defaults and a worked example. Call it before add_dashboard_card or update_dashboard_card on an analysis card: the dashboard renders from these fields only, so a wrong id gives an empty card, never an error. Question ids and codes come from get_results_map.
describe_analysis_card_type
Return the fields a card type accepts in `specs`, reflected live from the platform models — call it before create_card, create_cards or update_card when unsure of the expected shape. Pick the type with list_card_types first. Localized fields are keyed by the survey locale tokens. A field with a `default` takes that value when create_card or create_cards omits it — send it only to change it. `lint_rules` lists the checks the platform runs on this type: each finding opens a review thread (`lint_code`), never a 422.
describe_card_type
Replace the text of the survey context with the given Markdown. Keep the "## " sections the context already uses (Background, Objectives, Target, Brands and competitors, Hypotheses, Previous results, Other notes, Sources), the "[source]" citations after each statement, and send the WHOLE text: it overwrites the current one. Read it first with get_survey_context to edit it rather than rewrite it.
update_survey_context
Have Episto AI (re)write the survey context from the questionnaire and every source of the survey (files added through create_context_upload_link, texts added with add_survey_context_text). It REPLACES the current text, manual edits included. The generation is asynchronous: this call returns at once with status "generating"; call get_survey_context again after about a minute (longer with many new sources: each source is read on its own first, five at a time, and a source already read is reused), and keep waiting while the status is still "generating". "done" means the new text is in `content`, "failed" that Episto AI could not write it. A second call while one runs starts nothing.
generate_survey_context
Use when the user asks about the setup of one survey: status, study type, languages (`locales`, with the tokens update_survey needs), targeted audience (age, gender, countries), fieldwork targets with their sample size, median completion time and the validation `errors` of the questionnaire. Identified by its token. To give the link respondents answer on, call get_survey_links.
get_survey
Use when the user asks for survey results as figures: the distribution of answers per question, optionally broken down by respondent segments shown side by side. Question ids, answer codes for segment conditions and saved population tokens come from get_results_map. When get_results_map says `weighted: true`, these figures are weighted: say so the first time you give figures in a conversation, not in every answer, with the product word ("pondéré" in French, "Weighted" in English). Never call them weighted or raw when the map does not say it.
get_aggregated_data
One grid with its rows and its columns. An AI question column carries one cell per row, each with its `status` (pending, streaming, done, failed), its `answer` and the `citations` quoting the interview it comes from (only with `include_citations`). This is the tool to call again after ask_grid_question until every cell is done or failed. A cell names its subject by `respondent_id` (the `respondent_id` of get_individual_data) or by `search_group_id`, whose token and name are on the matching row (`search_group_token`, `search_group_name`). Rows come by pages of `limit` from `offset`, with the cells of those rows; `total_rows` gives the full count. On a population grid, `summaries` holds the comparative summary of each question.
get_grid
Use when the user asks to read individual answers, open-ended verbatims or AI Chat interviews, or to analyse themes across respondents. Returns a flat table with one row per respondent, keyed by a pseudonymous respondent_id. Each row may carry: per-question answers (categorical labels, raw text for open questions, numeric codes for scales); for an AI Chat study, a summary with focus-tagged highlights and focus_{index} interview transcripts (respondent turns prefixed R:, interviewer turns I:); and a boolean column per segment in segment_columns. Provide at least one of include_summaries, question_ids, or focus_ids. Question ids and focus_index values come from get_results_map.
get_individual_data
Use when the user asks how data collection is going: completed versus targeted respondents overall, then per target (audience segment) with the state of every quota. Each quota lists the tracked answer, its current count (n_total) and its expected count (target). quota_type "follow_up" marks quotas tracked for information only, without a hard target.
get_survey_progress
Use before reading survey results, to learn which questions can be analysed and the identifiers the results tools take. Returns every analysable question with its id, title, type and answer codes; for an AI Chat study, the interview objectives with their focus_index; the saved populations with their token and size; the collection period; and `weighted`, true when the results of this survey are weighted. Personal-data questions and media questions (email, postal code, image, audio, video) are excluded.
get_results_map
Use before filtering a completion funnel by campaign, audience or date range. Returns the values get_survey_completion accepts for one survey: master campaigns, campaigns and audiences (each as {value, label}, pass the value), and the first and last participation dates.
get_completion_filters
Use when the user asks where participants leave a survey: the completion funnel card by card, with where they screen out (disqualified by an answer) and where they drop out (abandon). Returns net_completion, net_screenout and overall_completion as rates between 0 and 1, plus per-card counts (n = participants who saw the card, n_screenout, n_drop, rates on the same 0-1 scale) and the screenout answers of each card. Returns {"status":"unavailable","reason":…} when the funnel cannot be computed: "no_participation" (nobody started yet), "no_match" (the filters keep nobody) or "not_tracked" (participants exist but their path card by card was not recorded, as in older studies; the fieldwork counts of get_survey_progress still hold). Explain that reason in plain words, without quoting the code, and never guess another one. Optional filters restrict the population; get_completion_filters lists the valid campaign and audience values.
get_survey_completion
Read the context of a survey: the brief (Markdown) that states its background, objectives, target, brands and competitors, hypotheses, previous results and other notes, each statement followed by its "[source]", and ends with a "Sources" map saying what each uploaded file or pasted text contains — read it to know which source holds what. The context describes the study, it is not what respondents answered: results come from the results tools only. When the answer needs more than the context says, ask that source a question with ask_survey_context_source. The list of sources, with their tokens, comes with it. Call it before analysing results or reviewing a questionnaire when the objectives of the study matter to the answer. `status` is "generating" while a generation runs (see generate_survey_context); `content` is null when nobody wrote nor generated it yet.
get_survey_context
Build the links respondents use to answer a survey, the ones the backoffice "Links" page hands out. A link is specific to a country and a language, and optionally to a chat page (the branded skin the questionnaire is served under). The test link replays the questionnaire without recording a respondent; the live link collects real answers, so only share it once the survey is ready. Without arguments it returns the default combination the backoffice preselects, along with every country, language and page available for this survey.
get_survey_links
Get the report of the fake respondents of a survey (see run_programming_check), waiting up to a minute while they are generated. `status` "none" means no test ran yet. Once "done", `issues` lists what will not work, each on a card, with what to change and why: `error` must be fixed before going live; `warning` must be checked, it may be intended; `info` explains the limits of the test. `profiles` gives how the respondents of each profile ended, `loi_minutes` the estimated length, `questions` the number of questions answered. Report the errors first, one line per card, with the change to make.
get_programming_check
The team's rules for writing and reviewing a questionnaire. `effective` is the list to follow for the survey (or the general rules without one): the general rules, then the rules of the account — when two contradict each other, the account rule wins. `lint_rules` are the checks the platform runs itself after every card save: each finding opens its own review thread (`lint_code` in list_review_threads), never blocking a save. `review_method` is how to review a questionnaire: follow it whenever you are asked for a review. Read the guidelines before creating cards, and never open a review thread for an issue a check already covers.
get_scripting_guidelines
The working map of a survey: its `locales` (the tokens keying every localized text), ordered sections, and ordered cards (token, type, name, section_token) each with its display_condition in plain words (null when shown to everyone), its question ids and its answers (code, token, title), plus the existing targets (with their audience conditions) and quotas. It carries the identifiers the target and quota tools take: the survey_id and target tokens for targets, the question_id and answer codes for quotas. Identifier semantics: quota answers use the answer `code` (1-based position), target condition values use the answer `token`; NPS/rating/slider conditions take integer values and "999" means skipped. Call it again whenever the user asks about the questionnaire: earlier answers in the conversation may be stale.
get_survey_map
Insert a block of Episto standard cards (GDPR notice, gender, age, postal code, CSP, income, satisfaction, opt-in, thanks, goodbye, AI consent) exactly as the editor does: the cards, their recodes and their conditions, translated to the survey locales. Prefer it to rebuilding these questions with create_card. `type` is a standard type from list_card_types (category standard). Placement works as in create_card. The platform answers 422 when a card of the block is already in the survey (same name) — rename or delete the existing one first.
insert_standard_cards
Use when the user asks which surveys (studies) exist in their Episto account, how many there are, or needs the token of a survey before calling another tool. Returns 20 surveys per page, most recent first, with name, status, study type, account name and respondent counts. `total` counts every matching survey across all pages: when asked how many surveys there are, answer with `total` (never the length of one page) and name the account(s) listed in `accounts`. Filters can be combined: name, status, account. "My surveys" means every survey the user can access: leave `mine_only` off unless the user explicitly asks for the surveys they created themselves; with it, `total_accessible` is how many surveys the user can access in all, to mention alongside.
list_surveys
List every analysis card of the results dashboards (crosstab, KPI, funnel, TURF, key drivers, map, word cloud…) with what each one shows and when to use it. Read it when the user asks for an analysis a plain question chart cannot give, to pick the `sub_type`; then describe_analysis_card_type for the exact content and options before add_dashboard_card.
list_analysis_card_types
Grids are the analysis tables built over the AI Chat interviews of a survey (AI Chat studies only). A respondent grid holds one row per respondent, a population grid one row per saved population. Every survey also has a default grid named "All respondents", addressed by the token `default`: it covers every respondent of the survey but stores no row, so its `row_count` is null. Each grid comes back with its AI `questions`; read the answers with get_grid.
list_grids
List every card type with its category (question, message, operation) and a one-line description of what it does — use it to pick the right `type` for create_card or create_cards, then describe_card_type for the specs it expects. The standard category lists the blocks of Episto standard cards, inserted with insert_standard_cards. A type with `creatable: false` can appear in existing questionnaires, but create_card refuses it for this user.
list_card_types
The contact attributes available on the mailing lists of a survey, which is what create_contact_attribute_recode recodes. `open` attributes hold free text and can only be kept verbatim; `single` attributes map each attribute name to the values actually seen, so those values are the ones a category can absorb. Call this before creating a contact attribute recode rather than guessing a name — a name that matches nothing produces an empty recode without any error.
list_contact_attributes
Use when the user asks what a survey measures, how the questionnaire is structured or how many questions it has. Returns every question, in order, with its id, card_token, name, title, question type and answer choices (code to label), recodes included; personal-data and admin-only questions are omitted. `question_count` is the number of questions the product shows, one per question card: give that number when asked how many questions a survey has. `questions` is finer: a matrix has one row per item and a ranking adds generated rows, so never count them. Call it again whenever the user asks about the questionnaire: earlier answers in the conversation may be stale.
list_survey_questions
List the results dashboards (views) of a survey, with their token and name. Use the token with get_dashboard to read a dashboard, or with the card tools to change its content.
list_dashboards
All review threads (comments left on the questionnaire) of a survey, oldest first: status ("open" or "resolved"), the card they are anchored to (card_token + card_name), author, resolver, and every comment of the discussion (body, author, mention_ids, and posted_via naming the AI assistant the author posted it through, null when written by hand). A thread with a `lint_code` was opened by a platform check. Use it to review outstanding feedback; then resolve_review_thread closes a handled thread and reply_to_review_thread answers when something needs clarification. Comment author ids can be used as mention_ids in replies.
list_review_threads
The populations saved on a survey, the same as the dashboards: token, name, color and filters (question id → selected answer codes). Their tokens are the rows of a population grid.
list_populations
Episto ChatGPT Plugin FAQ
How the directory, categories and Discoverability Score work.
Read the methodologyHow do I improve Episto's ChatGPT Plugin discoverability?
The levers are the listing surface agents actually read: names, descriptions, keywords, tool metadata, and registry health. Which lever matters depends on where discovery breaks, which is what continuous measurement shows.
What are Episto alternatives on ChatGPT?
As of 2026-11-20, Episto competes with AIlon, Askli, Attest, Audiense Insights, Audienzes Pro, august, Ballpark, Bazzly Reddit Research and 17 more in ChatGPT Audience & Market Research, ranked by public Discoverability Score.
Where is this profile measured?
This profile uses the geography attached to the latest public registry snapshot: US. Locale tags are intentionally omitted.