Can admins restrict ChatGPT Enterprise connectors?
Yes. Somebody in finance asks for Salesforce inside ChatGPT, and you want the boundary set before the first query runs.
Scope note before the detail: the OpenAI sections below are sourced to a specific help.openai.com article and a check date. Re-check a menu path on the live page before you write a runbook. The sections after "Where ChatGPT's per-action switches stop" describe Elaichi, a third-party MCP control plane, and how it extends those controls below the per-app level.
You can restrict ChatGPT Enterprise connectors app by app, and on Enterprise and Edu group by group. As of this check, apps are managed at Admin Console, then the workspace, then Plugins. The older page is Workspace settings, then Apps. It is also reached from Plugins through Manage Legacy Apps (help.openai.com, admin controls for plugins and apps, checked October 2026).
Plan matters more than anything else here:
| Plan | Workspace-wide app toggle | Per-group app assignment | Action-level controls |
|---|---|---|---|
| Free / Plus / Pro | No admin console | No | No |
| Team / Business | Yes, workspace-wide only | No | Yes, since 20 April 2026 |
| Enterprise / Edu | Yes | Yes, via custom roles | Yes |
The workspace-wide switch is the one control that exists on every paid team plan. Business workspaces start with apps on. New Enterprise and Edu workspaces start with a selected default set on. If you're auditing an existing workspace, don't assume the default. Read the current state directly.
How are ChatGPT Enterprise connectors different from the older connected apps?
OpenAI's current help pages call them apps. The article whose address still reads connectors-in-chatgpt is titled Connected apps in ChatGPT, so the two names land on one page. What changed is where admins manage them: apps now sit under Plugins, and the earlier Apps page remains as Manage Legacy Apps (help.openai.com, connected apps and admin controls, checked November 2026).
A thread on r/ChatGPT asks how the two differ. A plugin can include skills, apps and app templates, and plugin installation and app access are separate controls. Enterprise and Edu admins can use role-based access for both. OpenAI also lists two removals: administrator-managed app sync is no longer available, and standalone Google Docs, Sheets and Slides apps are no longer listed separately, because their actions run through the Google Drive app (help.openai.com, admin controls, checked November 2026).
Giving different groups different apps
Per-group app assignment is Enterprise and Edu only; it does not exist on Business at any price point. The path is Permissions & roles, then Custom roles, then Plugins & connected data, then Select. Roles are assigned to manual groups or groups synced via SCIM.
SCIM (RFC 7644) is the standard that syncs users and groups from your identity provider (Okta, Entra ID, etc.) into ChatGPT. So group membership in ChatGPT tracks group membership in your IdP, instead of being maintained by hand.
Two resolution rules matter in practice:
- Roles are additive. If any role a person holds grants a permission, they have it. There is no "most restrictive role wins": a second role can only add access, never subtract it.
- Propagation is not instant. Changes take up to 5 minutes to apply (help.openai.com, role-based access control in ChatGPT, checked October 2026). If you're testing a permission change, wait before concluding it failed.
On Business there is no group grain at all. Switching an app on switches it on for every member of the workspace. If your plan is Business and finance needs an app that support should not reach, that split cannot be built in the ChatGPT admin console. It has to live in an identity layer or a separate tool below the app.
Read actions, write actions and when ChatGPT asks first
Separate controls govern what an app may do and when the person is asked to approve it. Keep them distinct when you configure a workspace.
| Control | Location | Options | Governs |
|---|---|---|---|
| Actions | Per app | Read actions on/off, write actions on/off, set independently | Whether the app's read and write capabilities exist at all |
| New actions | Per app | Enable all new actions / Only enable new read actions / Disable new actions | What happens automatically when the connector ships a new capability |
| Plugin permissions | Workspace-wide or per app | Always ask / Allow read actions / Allow low-risk actions / Allow all actions (per-app only) | Whether the end user sees an approval prompt before a given call runs |
Business has had the Actions control since a release dated 20 April 2026 (help.openai.com, admin controls for plugins and apps, checked October 2026).
On Plugin permissions: members of a managed workspace never get a lasting "Always allow". No current OpenAI page documents what the default setting is for a newly enabled app. Check your own workspace rather than assuming "Always ask" or any other state (help.openai.com, managing app permissions, checked October 2026).
These controls only police what ChatGPT asks about. The destination system's own OAuth 2.0 scopes are a separate, independent check. OAuth is the browser sign-in flow that issues a scoped, revocable token instead of handing over a password. Salesforce's or Jira's own scope grants still apply underneath whatever ChatGPT allows.
Who may publish a custom MCP app
Only Admins and Owners can publish a custom app, on every plan tier that supports custom apps at all.
MCP (Model Context Protocol) is the open standard an AI client uses to discover a server's tools and call them. On Business, only admins and owners can create and publish a custom MCP app. On Enterprise and Edu, role-based access control can let regular members connect custom MCP servers from Plugins. The publish step, which sets the app's enabled actions and, on Enterprise and Edu, which groups receive it, stays with Admins and Owners.
Two behaviors to plan around:
- Snapshots, not live sync. A published app runs on a frozen snapshot of its tool list. If the connector adds a tool later, it arrives disabled by default until an admin manually refreshes the app.
- No verification, no escalation path. OpenAI does not review or verify custom MCP apps before publish. There is no documented member-to-admin request flow for "I need this app published" (help.openai.com, Connecting custom MCP servers in ChatGPT, checked October 2026). Whatever approval process you want has to be built outside ChatGPT. It lives in Slack, a ticketing system, or the approval step in front of the tool call itself.
Where ChatGPT's per-action switches stop
This is the architectural limit that the controls above cannot see past. It applies to a server that exposes a search tool and an execute tool instead of listing every connected tool, as Elaichi does.
To ChatGPT, Elaichi is one custom app whose listed tools are search_tools, execute_tool and Elaichi's own operations. The actual connected tools, a Salesforce record update or a Jira issue create, are never listed in tools/list, no matter how few of them exist. The model finds a connected tool at runtime by calling search_tools, then invokes it by calling execute_tool with the tool's identifier as an argument.
Consequence: ChatGPT's per-app Actions toggle (read/write) and its Plugin permissions prompt can only act on execute_tool as a single undifferentiated unit. They cannot distinguish a Salesforce read from a Jira write, because both are the same tool call from ChatGPT's point of view. Only the arguments differ, and ChatGPT's admin console does not inspect arguments. Elaichi annotates execute_tool as destructive and open-world precisely because its real risk tier can't be known until the call resolves.
The practical implication: setting the aggregator app to "read actions only" in ChatGPT does not make the connectors behind it read-only. That setting acts on execute_tool, which runs every connected tool, reads included, so it cannot single out the writes behind it. If you need read/write or connector-level granularity, it has to be enforced inside the aggregator, before the call leaves it. That is what the rest of this post describes.
What does a ChatGPT admin set, and what does Elaichi decide?
A ChatGPT admin sets which app exists and when the person is asked. Elaichi decides which connector and which tool that person may reach.
The ChatGPT controls all act on the app as a unit. That is the workspace switch, group assignment through custom roles on Enterprise and Edu, the read and write action toggles, and the Plugin permissions prompt (help.openai.com, admin controls for plugins and apps and managing app permissions, both checked October 2026).
Elaichi's tool list is where that grain stops. It carries search_tools, execute_tool, and run_code where Code Mode is on. It also carries two Elaichi operations that run connected tools, elaichi__toolbox__execute and elaichi__synthetic_tool__execute. No name in that list names a connected app. A client control that gates individual tool names can therefore act on those four as wholes, and nothing finer. Gating execute_tool alone leaves the other three. Per-app and per-tool control is written in Elaichi instead, as a restriction on a role or on one member.
No ChatGPT permission setting makes the connected apps read-only. None of the tools that run connected tools is annotated read-only. Elaichi marks execute_tool and run_code destructive and open-world, and the two Elaichi operations are writes. So a setting that lets read-only tools run unprompted prompts for every connected-app call, reads included. It does not hold the connected apps to reads.
Writing per-app and per-tool rules in Elaichi
From here on, this describes Elaichi specifically, not an OpenAI feature.
Elaichi enforces per-app and per-tool rules as restrictions, written server-side, independent of ChatGPT's own permission model. A restriction names which connectors and which individual tools a target may reach. In Elaichi, restriction targets are role or user only; the organization default is the absence of a rule, which means allow everything.
Resolution logic:
- A member is governed by two layers at once. One is their role's rules. The other is any rule aimed at them personally. A tool is reachable only when both layers admit it, so a personal rule can only narrow what the role allows. It never replaces or loosens a role rule.
- Within each layer, allow rules union and block rules union.
- Blocks always beat allows, regardless of which rule was written more recently or more specifically.
- An allow rule naming nothing denies everything. In Elaichi, the allowlist stage engages on the presence of an allow rule, not its contents, so an allow rule that names nothing denies everything. It is an easy rule to write by accident when a restriction is left half-filled.
- An allow rule naming a connector as a whole grants every tool on that connector, even if specific tool entries are also listed. The tool entries in that case add nothing beyond what the connector-level grant already covers.
Matching detail that affects correctness: blocks match on the tool's name or on the operation pinned against the catalog. Allows match the pinned operation only. The reason is that a tool's advertised display name can be edited by whoever maintains the connector's documentation. Matching allows against a name would let a documentation edit silently widen access. A restricted tool is left out of the tools Elaichi offers a client and cannot be called. Search still names it, flagged restricted, with no schema. A restriction change takes effect within about two minutes.
Elaichi serves 900+ connectors, most of them authored on its own infrastructure, on one organization-wide endpoint, https://api.elaichi.ai/mcp. Because the restriction is enforced at that endpoint rather than inside any one client, a restriction written once for a role applies identically. That is true whether the member is using Claude, ChatGPT, Cursor, Microsoft Copilot or any other MCP client. Each client sees the same filtered tool list and the same enforcement, because the filtering happens before the response reaches the client.
Each member holds exactly one role, which is why roles are built as complete personas rather than stacked fragments. The walkthrough of when to block a tool and when to block the app covers how to choose the grain for a given rule.
Failure mode to plan for: because enforcement happens at api.elaichi.ai, that endpoint is a dependency for every connector call from every client. If it's unreachable, calls fail closed: ChatGPT's execute_tool call returns an error rather than falling back to a direct, unfiltered connection to Salesforce or Jira. This also means every connector call takes one additional network hop versus a native, unmediated connector. Whether that overhead matters depends on your latency budget. Measure it against your own traffic rather than taking it on faith.
How do you roll this out so each person only sees their own data?
Roll it out one team at a time, and decide per app whether people connect their own account or share one. Who the app sees on the other end is set by the connection, not by the chat client.
Start with a pilot team of a handful of people on one role. Write that role's restriction before anyone connects, then have the pilot members connect their clients and work normally for a week.
The per-person question is the one that decides what each person sees. Every call through a connection runs on the account behind that connection, whoever makes the call. So a connection one person shares with a team runs as that person in the app, for everyone. If you want the app's own permissions to apply per person, each person needs their own connection: their All tools toolbox, a toolbox built on their own connections, or a template each person stamps while picking their own connection for each connector. A toolbox shared with a team runs each entry on the connection pinned in it, under the authority of whoever pinned it.
So the order within the pilot is:
- Write the role's restriction: allow rules for the approved connectors, blocks for the tools nobody in that role should reach.
- Decide, per app, between per-person connections and one shared connection. Per-person keeps each person's own permissions in the app. A shared connection gives everyone one fixed permission set.
- Have an Admin or Owner create and publish the custom app in ChatGPT, setting its actions and, on Enterprise and Edu, the groups it goes to.
- Have each pilot member connect and approve their own grant on Elaichi's consent screen.
- Run the validation runbook below before anyone else is added.
Expand one role at a time after the pilot passes. Each new role gets its own restriction written before its members connect, because a restriction added later does not undo calls already made. On Enterprise and Edu, the group assignment on the published app is the second gate: a role's members only see the app once their group receives it.
How do you test that the boundary holds?
Run three checks with a real member on a real role, and read the audit log after each one. Give a new restriction about two minutes before testing it.
Check one: a record the person can open. Have the member ask their client for a record they already have access to in the app. It should come back. This is the control: it proves the connection, the role and the published app all work before you test a refusal.
Check two: a record the person cannot open. Have the member ask for a record their own account in the app cannot see. On a per-person connection, the app itself refuses or returns nothing, because the call runs as them. On a shared connection it will not refuse on those grounds, because the call runs as the connection's owner. If that surprises you, the connection model is the thing to change, not the restriction.
Check three: a blocked tool. Have the member ask for something that needs a tool the role's restriction blocks. Elaichi refuses in-band and tells the caller whether the block comes from their role or from their own account, and that an admin can lift it through an access request. The refusal does not name the rule, who wrote it or what else it covers. A restricted tool is left out of the tools Elaichi offers a client and cannot be called. Search still names it, flagged restricted, with no schema.
Then read the audit log. Filter by category, the member and a start time, and read the client each tool-call entry names. Elaichi writes one entry for each connected-tool call that reaches execution (a call refused earlier writes none), plus the surface, the OAuth client the call came through, and how the call was approved. Each entry also carries the connection the call actually reached, which is how you confirm whose account answered. Two notes on reading it: a call Elaichi refuses before execution, such as a tool a restriction withholds, writes no entry at all, so check two and check three show up differently. And the log is eventually consistent, so wait a moment rather than treating an immediate query as final.
Write down what each check returned and which audit rows it produced. That record is what you hand to whoever asks later whether the boundary was tested.
Where each layer's record lives
The two layers, ChatGPT's own logs and Elaichi's audit log, keep separate records, and neither is a superset of the other.
ChatGPT's Compliance Logs Platform is Enterprise and Edu only (Business has no equivalent). APP_LOG events carry the user's id and email, the app identifier (app_type includes MCP for custom apps), the conversation id, and the request/response payload. Relevant admin events include APP_SET_ENABLED_ACTIONS, ROLE_SET_PLUGIN_PERMISSIONS, and PLUGIN_USE_BLOCKED. Files are retained 30 days. No field documents the specific tool name that was called inside an aggregator app (OpenAI, compliance API reference, checked October 2026). That is precisely the gap that makes the per-action limit concrete: ChatGPT's own logs cannot tell you which connector or tool ran inside execute_tool.
Elaichi's audit log is the append-only record of what a tool-call entry has to capture at the tool level. Elaichi writes one entry for each connected-tool call that reaches execution (a call refused earlier writes none). The entry holds the one path argument that names the object, as the target id, and no other argument: no argument names, no count, and no other values. Each entry records the client surface and the OAuth client the call arrived through. Claude, ChatGPT, and Cursor are distinguishable from each other by their registered redirect URIs. Each entry also states how the call was approved, which over MCP corresponds to the scope the client was granted at consent. The log is eventually consistent, so a row can take a short time to appear after the call completes. Don't treat an immediate query as authoritative.
The order to set this up
This sequence is Elaichi-specific. Write the restrictions before anyone connects. A person who signs in first can connect any catalog app their role allows. A restriction added afterward does not retroactively apply to calls already made.
- Decide the roles. One role per member, each a complete persona.
- Write a restriction per role in Elaichi: allow rules for the approved connectors, blocks for the specific tools nobody in that role should reach.
- Create the custom app in ChatGPT under Workspace settings, then Apps, then Create. Paste
https://api.elaichi.ai/mcpexactly, with no trailing slash, then Scan Tools and complete the OAuth prompt. - Publish the app, setting its enabled actions and, on Enterprise and Edu, the groups it's assigned to.
- Set Plugin permissions to control how often ChatGPT prompts before a call.
- Have each member connect and sign in. They choose scopes on Elaichi's own consent screen at connection time, and that per-person grant is independent of the role-level restriction and cannot exceed it.
- Read the first week of calls in Elaichi's audit trail, filtered by category, the member and a start time, and read the client each tool-call entry names. Confirm the restrictions behaved as written before you treat the rollout as done.
The client-side detail of step 3 and step 6 is covered in the ChatGPT connection walkthrough.
When the native controls are enough
If ChatGPT is the only AI client your organization will run, stop at the native controls described above. That holds when every app your teams need is already in OpenAI's own catalog with the granularity you need. The workspace switches, custom roles, and action controls cost nothing beyond your existing ChatGPT plan. Adding another layer for a problem you don't have is pure overhead.
A control plane like Elaichi earns its place under two conditions, not before. The first: a second MCP client enters the picture (Claude, Cursor, an internal agent), and you need the same restriction to apply in both without maintaining it twice. The second: the access rule you need is finer than "this app, on or off". That means a specific tool inside a connector rather than the whole connector. The Claude side of that two-client case is set out in approving apps for Claude across a company.
The case against adding a layer prematurely is set out in when a gateway is premature. The trade-off against OpenAI's built-in apps is in native connectors versus one endpoint. For the architecture underneath all of this, see what an MCP control plane is. To check whether your teams' apps are covered, see the connector catalog or team use cases.