add_client_account
ChatGPTMap an enabled connector account to a client. This links the account so it can be used in the client's goals, dashboards, and data queries. Only enabled accounts can be mapped — if the account is not yet enabled, call enable_account first. Use get_connector_accounts(status='enabled') to find accounts available to map.
create_client
ChatGPTCreate a new client for the team. A client represents a business or advertiser the team manages (e.g. an agency client). If a domain is provided, the client's logo is automatically fetched from the domain — no extra step needed. Custom logos can be uploaded from the hub. After creating, use add_client_account to map connector accounts to the client.
create_connection_setup_link
ChatGPTCreate a secure link the user opens in a browser to connect a data source (Google Ads, GA4, Facebook Ads, Search Console, Shopify, Klaviyo and others) to the team, or to reconnect an expired connection with mode='edit' and its connectionId. The user, or a colleague who holds the credentials, signs in to the platform on that page. Never ask for passwords or API keys in chat. The link needs no Two Minute Reports login and works until a connection is saved through it, for up to 7 days, so share it only with the person who should connect the account. Each call creates a new link; one person can create up to 10 a day, so reuse a link that is still pending. connectionName must be plain words: names with links (https://…, www.…), HTML or words such as verify, password, credentials or urgent are refused. When the user says they have finished, check it with get_connection_setup_link. If a link stays in_progress for minutes, create a new one.
create_custom_field
ChatGPTCreate a custom metric (a numeric value that aggregates across rows) or a custom dimension (a categorical value rows are grouped by) for the team. The new field is available immediately: its 'tmr_custom_*' id works in run_query, in dashboard widgets, in goal targets and in filters. Field ids inside formulaItems, conditionBlocks and mappings are connector-prefixed, exactly as get_connector_query_schema returns them for that connector — 'ga4_sessions', 'gadw_clicks', 'fads_spend'. configurationMethod: • 'formula' — one expression, built from formulaItems. type 'field' references a connector field, type 'constant' is a literal, type 'operator' joins the items either side. Metrics evaluate the expression as arithmetic; dimensions concatenate it into a string. Add conditionRules when the formula differs by condition: rules are evaluated in order and the first match wins, so a rule with setConditions false placed last acts as the 'else'. • 'join' — blending, for a metric that exists on several platforms under different names. Map one source field per connector in join.perSourceConfigs, keyed by connector id. On a blended row a metric SUMS every mapped source's contribution and a dimension takes the first mapped source with a value; on a single-connector row only that connector's mapping is used. Per-connector arithmetic is allowed, which is how a field reported in micros is normalised before it is blended. • 'split' — dimensions only. Split splitConfig.sourceField on a delimiter, keep one fragment, and optionally rewrite the result through valueMappings. fallbackValue decides what the field returns when it cannot be computed — no rule matched, an invalid expression, or no source contributed. Each call creates a new field; calling it twice with the same arguments produces two fields with different ids, not one. Nothing leaves Two Minute Reports: the definition is stored on the team.
create_dashboard
ChatGPT⚠ Hand-building pages/widgets? Read get_dashboard_guidelines first (once per conversation — reuse it, don't refetch) for widget types, layout rules, and data field rules. (Skip it for the generate_* tools and for simple metric/dimension tweaks to existing widgets.) Flow: (0) get_dashboard_guidelines. (1) list_connectors + get_connector_accounts to resolve accounts. (2) get_connector_query_schema for field IDs. (3) validate_query with raw unprefixed IDs. (4) Build widgetConfig with connector-prefixed IDs (e.g. 'sessions' → 'ga4_sessions'). (5) Call create_dashboard once with all pages assembled. Do NOT call run_query — the dashboard renders its own charts.
create_goal
ChatGPTCreate a new goal. There are two types: • standalone_goal — tracks any performance metric (leads, ROAS, conversions, revenue, etc.). Can optionally be linked to a parent budget_goal via parentId (accountIds are then inherited from the budget). progressDirection: 'positive' (higher is better) or 'negative' (lower is better, e.g. CPA, CPL). • budget_goal — tracks blended ad spend against a budget cap. performanceMetric is always 'blended_amount_spent' — do not ask the user, just send that value. progressDirection is always 'positive' (handled by backend — do not send it). Before calling this tool, ask the user: 1. Is this goal for a specific client or team-wide? • Client-scoped: resolve clientId via list_clients, then list_client_accounts for their accounts. • Team-wide (clientId omitted): use get_connector_accounts(status='enabled') to let the user pick accounts. 2. For standalone_goal: what metric are they tracking and what connector is it from? Use get_connector_query_schema to show available metrics if needed. 3. What is their numeric target, currency, and date range?
disable_account
ChatGPTDisable a connector account for the team. The account will no longer be used for data retrieval and frees up a slot in that connector's limit. It is not deleted — it can be re-enabled later. Confirm with the user before calling.
enable_account
ChatGPTEnable a connector account for the team. Only enabled accounts can be used to retrieve data, appear in goals and dashboards, and run analytics queries. Enabled accounts count toward that connector's own account limit. Use get_connection_accounts or get_connector_accounts(status='disabled') to find accounts to enable.
export_dashboard
ChatGPTStarts an export of a dashboard as a PDF, or as PNG images. The export runs in the background. It can take several minutes. Dashboards with more pages and widgets take longer. The tool returns an exportId at once. If status is already completed, use files from this result. Otherwise call get_dashboard_export with the exportId until status is completed or failed. Do not call this tool again while you wait. Omit pages to export every page. One export can have at most 30 pages. Omit dateRange to use each page's saved date range. If the user did not name dates or a period, ask before you call this tool. Ask whether to use each page's saved date range or other dates, for example last month. Filters always come from the saved dashboard. This tool can't change them. Anyone who has a download link can download the file. No sign-in is needed. The same request within 1 hour returns the same export, with reused set to true. The same request means the same dashboard, pages, dates and format, with no dashboard changes since. A team can have 2 exports in progress, and can start 30 exports in 24 hours. Reused exports don't count. When a limit is reached, tell the user the error. Do not call the tool again at once.
get_client
ChatGPTGet details of a specific client including their name, domain, status, metadata (logo/brand), and creation date. Use outputFields to select which response fields are returned.
get_connection
ChatGPTGet details of a specific connection including the platform type, status, and number of linked accounts. Use outputFields to select which response fields are returned, e.g. ['id', 'status'] for a status check without the connector-specific config blob.
get_connection_accounts
ChatGPTList accounts exposed by one specific connection. Use this only during onboarding or connection setup — when the user has just created a connection and wants to see what accounts are available under it before enabling them. For finding accounts to use in queries, goals, or dashboards, use get_connector_accounts(status='enabled') instead — it covers all connections for a connector in one call. Supports sortBy, filters, and limit.
get_connection_setup_link
ChatGPTCheck a link created by create_connection_setup_link. status is pending (not completed yet), in_progress (saving), used (connection created or updated; connectionId is set), expired or revoked. Once used, list the connection's accounts with get_connection_accounts(connectionId); accounts not yet enabled show status 'disabled' and enable_account turns on the ones the user picks. An expired or revoked link cannot be reused; create a new one.
get_connector_accounts
ChatGPTList all accounts for a connector type across all its connections in a single call, with their enabled/disabled status. This is the preferred tool whenever you need accounts for a specific platform — use status='enabled' to get all active accounts ready for queries, goals, and dashboards without having to iterate individual connections. Use status='disabled' to find accounts still needing activation. If connectorId is omitted, returns accounts across all connectors. If there are multiple accounts returned, you must present the list and ask which accounts to use. Supports sortBy, filters, and limit.
get_connector_query_schema
ChatGPTGet the full query schema for a connector — available fields, report modes, required params, and validation rules. Always call this before constructing any query for validate_query or run_query. For standard connectors (GA4, Google Ads, Facebook Ads, etc.) it returns grouped metrics and dimensions. For PSI, Amazon Seller, and Google Search Console it returns the full query schema including report modes, required params, allowed values, and rules you MUST follow when building the query. PSI rule: the 'urls' field MUST be provided by the user — never auto-generate, infer, or guess URLs. If the user has not explicitly provided URLs, ask them before calling run_query.
get_dashboard
ChatGPTGet details of a specific dashboard. Omit outputFields to get everything including full widget definitions (e.g. before update_dashboard). For a lightweight overview without the widgetConfig payloads pass outputFields like ['id', 'name', 'pages.name', 'pages.widgetCount', 'pages.widgetTypes', 'theme', 'reportDefaults'] — ideal when you just need to understand what a dashboard contains or list its pages.
get_dashboard_export
ChatGPTGets the status of a dashboard export, and its download links when it is ready. Each call waits up to 20 seconds for the status or progress to change. While status is queued or rendering, call this tool again. pagesDone of pagesTotal shows the progress. If the export takes a long time, tell the user the progress. You can check again later with the same exportId. When status is completed, give the user files[0].url. files[0] is the PDF, the image of a one-page PNG export, or a ZIP of all pages. Give the links of single pages only when the user asks for them. Always use each url as returned. Anyone who has a link can download the file. No sign-in is needed. Tell the user the date in expiresAt. The links stop working after it. If warnings is not empty, tell the user which widgets did not load, and on which page. A widget with state loading shows a loading placeholder in the file. A widget with state failed shows an error. If status is failed, tell the user error.message. If status is expired, the files were deleted. Call export_dashboard to make a new export.
get_dashboard_guidelines
ChatGPTReturns the structural spec for hand-building TMR dashboard widgets — every widget type, its widgetConfig shape, layout/grid rules, and data-field rules. (Theme/palette/typography are inherited from the existing dashboard, not covered here.) Call this ONCE before hand-building a dashboard/widget config (create_dashboard / update_dashboard), then REUSE it for the rest of the conversation — do NOT refetch on every call. NOT needed for the AI generators (generate_dashboard / generate_dashboard_page), nor for changing a metric/dimension/chart type on an existing widget (use get_connector_query_schema + validate_query for that). Hand-built dashboards that ignore these guidelines will have structural errors and render incorrectly.
get_goal
ChatGPTGet full details of a specific goal including its performance metric, target value, date range, progress direction, and the connector accounts it is measured against. Use outputFields to select which response fields are returned.
get_team
ChatGPTGet details for the team — plan name, usage limits, and member count.
get_team_members
ChatGPTList all members of the team, with the role each one holds and whether they have a seat. Every team has the same six standard roles — viewer, editor, data_manager, deputy_admin, admin, owner — and may define its own, in which case roleCode is null and roleName carries the team's name for it. A seat is separate from a role: a member without one sees everything their role allows and is refused every write. Supports sortBy, filters, and limit.
get_user
ChatGPTGet the current user's profile including name, email, and avatar.
list_client_accounts
ChatGPTList the connector accounts mapped to a specific client, optionally filtered by connector type. Use this when the user's question is about a named client and you need to know which accounts belong to them. The returned accountIds are what you pass to validate_query and run_query. If the user has not mentioned a specific client and just wants accounts for a connector, use get_connector_accounts(status='enabled') instead. Supports sortBy, filters, and limit.
list_client_contacts
ChatGPTList the people the team saved as contacts at its clients. Each contact has a name, an email address, a job title and a note. Set clientId to list the contacts of one client. Omit clientId to list the contacts of every client in the team. Use list_clients to find the clientId for a client name. Use this tool to find the people who receive a client's briefings and setup links. This tool only reads contacts. It cannot add, change or delete a contact. Supports sortBy, filters, limit and outputFields.
list_clients
ChatGPTList all clients for the team. A client represents a business or advertiser the team manages (e.g., an agency client). Clients group related connector accounts together and are used to scope goals and dashboards. Call this when the user refers to a client by name to resolve its clientId. Use outputFields to pick which response fields each item includes (e.g. ['id', 'name'] for name resolution); supports sortBy, filters, and limit.
list_connections
ChatGPTList all data source connections for the team. A connection is an authenticated link to an external platform (e.g., a Google Ads OAuth login or a Facebook Ads account). Use this for connection management tasks — checking OAuth status or troubleshooting a specific integration. To find accounts for data queries, dashboards, or goals, use list_connectors then get_connector_accounts(status='enabled') instead — it is faster and covers all connections in one call. Supports outputFields (pick which response fields each item includes, e.g. ['id', 'name', 'status'] to skip the config blob), sortBy, filters, and limit.
list_connectors
ChatGPTList all connector types active for the team (e.g., GA4, Google Ads, Facebook Ads) with the count of connections and enabled accounts per connector. This is the first step when you need to discover what data sources are available — call this before get_connector_accounts to know which connectorIds to query. A connector is a platform type; a team can have multiple connections per connector (e.g., two separate Google Ads logins) but this tool aggregates them all into one row per platform. Supports sortBy, filters, and limit.
list_custom_fields
ChatGPTList the team's custom fields: metrics and dimensions the team defined itself, on top of the native connector fields. Their ids start with 'tmr_custom_' and are valid wherever a native field id is, in run_query metrics, dimensions and filters — the platform resolves them when the query runs. Each field says how it is computed: 'formula' (an expression over connector fields), 'join' (blending — one source field mapped per connector), or 'split' (a fragment taken out of a naming convention). Use outputFields to keep responses small — a full definition includes every formula item — and sortBy, filters and limit to narrow the list.
list_dashboards
ChatGPTList all dashboards for the team. A dashboard is a collection of data visualisation widgets, each backed by an analytics query. Dashboards can be client-scoped (clientId is set — widgets can only use accounts mapped to that client) or team-wide (clientId is null — widgets can use any enabled account across any client or unmapped accounts). Dashboards render their own charts and do not require run_query. Full pages/theme payloads are returned unless narrowed — prefer outputFields like ['id', 'name', 'clientId', 'pageCount', 'widgetCount'] when browsing; supports sortBy, filters, and limit.
list_goals
ChatGPTList all performance goals for the team. A goal tracks a specific metric target (e.g., achieve 10,000 sessions, keep CPC below $2) over a defined period, measured against one or more enabled connector accounts. Goals can be client-scoped (clientId is set — only accounts mapped to that client can be used) or team-wide (clientId is null — any enabled account across any client can be used). Use outputFields to pick which response fields each item includes (e.g. pass ['id', 'name', 'entityType'] to check which goals are standalone); supports sortBy, filters, and limit.
run_query
ChatGPTExecute analytics queries for one or more connectors and return data rows. Supports multiple connectors in a single call — pass one entry per connector in the 'connectors' array. Required flow: get_connector_query_schema → construct query → validate_query → run_query. Queries must be validated via validate_query before execution. Before executing: must show the query to the user, explain what it will fetch, and ask if they want any changes. Only call run_query after they confirm. All queries across all connectors run in parallel. Use this only for ad-hoc data insights where the user wants actual numbers returned in the conversation. For dashboard widgets do NOT call run_query — embed the validated query object directly as the widget's widgetConfig instead. FIELD IDs: always raw, no connector prefix (e.g. 'sessions' not 'ga4_sessions'). connectorId is per-entry, NOT a prefix. Account IDs: pass raw account IDs without prefix (e.g. '123456789' not 'ga4_123456789'). CUSTOM FIELDS (list_custom_fields) are the exception to the raw-id rule: pass the full 'tmr_custom_*' id unchanged in metrics, dimensions, filters or sort. A blended custom field ('join') returns only the queried connector's share, not its cross-platform total — each connectors entry runs one connector. Sum the per-connector results to state a total. After returning the results, suggest the next step that fits what the user is trying to do — keep it on a dashboard (create_dashboard), track it as a goal (create_goal), or turn a calculation they asked about into a reusable custom field (create_custom_field). SORTING: use query.sort ([{sortField, direction: 'asc'|'desc'}]) to order result rows — e.g. for 'top campaigns by clicks' sort by 'clicks' desc. sortField must be one of the query's own metrics/dimensions. Default when omitted: ascending by dimensions. REPORT CONNECTORS — some connectors use query.reportParams instead of (or alongside) metrics/dimensions. Always call get_connector_query_schema first for the connector — it tells you required reportParams fields, which metrics to pass, and any rules.
share_dashboard
ChatGPTShows or changes who can open a dashboard's share link, and returns the link. Call it with only teamId and dashboardId to see the current access without changing it. If the dashboard has no share link yet, the tool makes one. A new link opens only for the people its access allows. Pass access, addPeople or removePeople to change it. The result shows the access after the change. Team members can always open the share link, at every access level. Restricted: team members and the people listed. Client contacts: team members, the people listed, and every contact saved on the dashboard's client. Only for client dashboards. Anyone with the link: everyone who has the link, with no email code. Below Anyone with the link, each person confirms their email with a one-time code before the dashboard opens. Ask the user before you set access to anyone. Everyone who gets the link then sees the dashboard's live data. This tool does not send email. Give the user link.url so they can send it. Always use link.url as returned. Teams with a custom domain have links on their own host. People who open the share link can change the date range. They can't change the dashboard's filters. The dashboard's own page in Two Minute Reports always needs a login. Send the share link instead.
update_client
ChatGPTUpdate a client's name or domain. Only send the fields that should change. If domain is updated, the logo is automatically re-fetched from the domain (unless a custom logo has been uploaded from the hub).
update_custom_field
ChatGPTChange an existing custom field's definition. Send only the keys that change; anything omitted keeps its current value. Each key is replaced whole, never merged: join, formulaItems, conditionRules and splitConfig discard their previous value, so send the complete new one. Get customFieldId from list_custom_fields. This edits a definition other things already depend on: every dashboard widget, goal and saved query that selected this field starts computing the new definition, including for periods already reported. A field cannot change between metric and dimension, because whatever already references it selected it as one or the other. Sending configurationMethod switches the field to that method and discards the configuration the previous method used, so send the new method's own config in the same call. Field ids inside formulaItems, conditionBlocks and mappings are connector-prefixed, exactly as get_connector_query_schema returns them for that connector.
update_dashboard
ChatGPT⚠ Hand-building pages/widgets? Read get_dashboard_guidelines first (once per conversation — reuse it, don't refetch) for widget types, layout rules, and data field rules. (Skip it for the generate_* tools and for simple metric/dimension tweaks to existing widgets.) Update an existing dashboard — rename, change scope, replace pages/widgets, update reportDefaults or theme. Only provided fields are updated; omit the rest. Always call get_dashboard first (without outputFields, so full pages are returned) to read current pages before modifying. Pages are replaced wholesale — partial page updates are not supported. Do NOT call run_query for dashboard widgets.
update_goal
ChatGPTUpdate an existing goal's fields. Only send the fields that should change — all fields are optional. Do NOT change entityType or performanceMetric to an incompatible type (e.g. swapping from a spend metric on a budget_goal). Use get_goal first if you need to confirm current values before updating.
update_user_name
ChatGPTUpdate the current user's first and last name. Both are required.
validate_query
ChatGPTValidate queries for one or more connectors before executing them. Supports multiple connectors in a single call — pass one entry per connector in the 'connectors' array. Query construction flow: (1) Call get_connector_query_schema for each connector to discover field IDs. (2) Construct each query: choose metrics and dimensions by raw 'id' values, set date range, add filters. For report connectors, leave metrics/dimensions empty and populate query.reportParams instead. (3) Call this tool — each query is validated independently and errors name exact field IDs or rule violations. (4a) If the user wants data: pass the same connectors array to run_query. (4b) If for a dashboard widget: convert field IDs to connector-prefixed format before embedding. PREFIXING RULE — validate_query / run_query use RAW IDs; dashboard widget configs use PREFIXED IDs: validate_query / run_query → accountIds: ['123456789'] metrics: ['sessions'] dimensions: ['date'] widget widgetConfig → accounts: ['ga4_123456789'] metrics: ['ga4_sessions'] dimensions: ['ga4_date'] Prepend '<connectorId>_' to EVERY field and account when moving from query to widget. CUSTOM FIELDS (list_custom_fields) are the exception: pass the full 'tmr_custom_*' id unchanged.
verify_team_details
ChatGPTVerify the user's identity and retrieve the teams they belong to. Always call this first — every other tool requires a teamId. Each team includes a planStatus field. Plan status values: - 'active', 'in_trial', 'non_renewing' → plan is active; all tools are available. - 'cancelled' → the team's plan is not active Do NOT call any create, update, delete, validate_query, or run_query tools for a cancelled team. If the user belongs to multiple teams, you must present the list and ask which team to work with — note any cancelled teams so the user can pick an active one. Store the chosen teamId for all subsequent tool calls. WORKFLOW — discovering accounts for data queries, dashboards, or goals: 1. list_connectors — see which platform types (GA4, Google Ads, etc.) the team has active. 2. get_connector_accounts(connectorId, status='enabled') — get all enabled accounts for that platform in one call. Do NOT use list_connections → get_connection_accounts for this — it makes one extra call per connection and returns the same information less efficiently.
