# O ChatGPT consegue publicar pelo Shager? Sim: conecte com login ou use um de outros três caminhos

_2026-09-05 · Os conectores MCP do ChatGPT entram com OAuth, e o Shager aceita: adicione o Shager no modo desenvolvedor, entre e aprove. E ainda Codex, a API e um script._

Consegue. Os conectores MCP personalizados do ChatGPT se autenticam com OAuth, e o servidor MCP do Shager aceita login via OAuth. Adicione https://app.shager.ai/api/mcp como conector no modo desenvolvedor, entre no Shager e aprove, sem chave para copiar. Você também pode colocar os modelos da OpenAI para trabalhar no Shager pelo Codex, pela API da OpenAI ou usando o ChatGPT para escrever e um script curto para fazer a entrega.

Este artigo mostra como adicionar o conector e traz código funcionando para cada um dos outros caminhos.

## Como adicionar o Shager como conector do ChatGPT?

O guia da OpenAI sobre [autenticação para apps no ChatGPT](https://developers.openai.com/apps-sdk/build/auth) descreve o modelo suportado: servidores que precisam de autenticação implementam um fluxo OAuth 2.1 de acordo com a especificação de autorização do MCP, com preferência por Client ID Metadata Documents e com suporte também a registro dinâmico de clientes. Os servidores também podem funcionar sem autenticação. O mesmo guia afirma que o ChatGPT não consegue enviar chaves de API personalizadas.

O servidor do Shager em https://app.shager.ai/api/mcp segue essa especificação, com Client ID Metadata Documents e também registro dinâmico de clientes. Para conectar:

1. No ChatGPT, abra Settings, depois Apps & Connectors, ative o Developer mode e clique em Create.
2. Dê o nome `Shager`, informe `https://app.shager.ai/api/mcp` e escolha OAuth.
3. Clique em Connect. O Shager abre: entre, escolha a organização e aprove.

O modo desenvolvedor está disponível nos planos pagos do ChatGPT. A conexão pode ler e criar rascunhos. Agendar e publicar é uma caixa de seleção separada na tela de aprovação, desmarcada a menos que você a marque, e você pode desconectar a qualquer momento em https://app.shager.ai/dashboard/agents.

### Por que não colocar um proxy sem autenticação na frente de uma chave de API?

Tem gente que sugere isso, e é uma péssima ideia, ainda mais agora que você não precisa disso. Um proxy que aceita requisições sem autenticação e injeta a sua chave do Shager transforma o acesso de publicação da sua agência num endpoint público. Qualquer pessoa que encontrar a URL pode criar rascunhos nos workspaces dos clientes e, com uma chave `publish`, agendá-los. Não faça isso.

## Caminho 1: Codex, o agente de programação da OpenAI

Se o que você quer é "um modelo da OpenAI operando o Shager", o Codex já faz isso de forma limpa. Ele aceita bearer tokens vindos de uma variável de ambiente para servidores MCP com HTTP streamable, então a configuração são poucas linhas em `~/.codex/config.toml`:

```toml
[mcp_servers.shager]
url = "https://app.shager.ai/api/mcp"
bearer_token_env_var = "SHAGER_API_KEY"
```

A documentação de MCP da OpenAI observa que o app desktop do ChatGPT, o Codex CLI e a extensão para IDE compartilham esse arquivo de configuração. O passo a passo completo, incluindo uma lista de ferramentas permitidas, está em [como conectar o Shager ao Codex](/en/blog/connect-shager-to-codex).

## Caminho 2: a Responses API da OpenAI com uma ferramenta MCP remota

Se você está construindo seu próprio agente sobre a API da OpenAI, a Responses API consegue chamar servidores MCP remotos por conta própria. O [guia de conectores e MCP](https://developers.openai.com/api/docs/guides/tools-connectors-mcp) documenta uma ferramenta `mcp` com `server_url`, um campo `authorization` para o token de acesso, `allowed_tools` e `require_approval`. A documentação também observa que a API não guarda o valor de `authorization`, então você o envia em toda requisição.

```python
import os
from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model=os.environ["OPENAI_MODEL"],
    input=(
        "In the Shager workspace 'Cedar Clinics', list the channels, then create a "
        "DRAFT post to all active channels announcing Saturday walk-in hours. "
        "Use a different caption per channel that names the clinic's town. "
        "cta_url https://cedarclinics.example/walk-in, campaign 'walk-in-sat'. "
        "Do not pass schedule_at."
    ),
    tools=[{
        "type": "mcp",
        "server_label": "shager",
        "server_url": "https://app.shager.ai/api/mcp",
        "authorization": os.environ["SHAGER_API_KEY"],
        "allowed_tools": [
            "whoami", "list_workspaces", "list_channels",
            "list_groups", "create_post", "get_post",
        ],
        "require_approval": {
            "never": {"tool_names": ["whoami", "list_workspaces", "list_channels", "list_groups", "get_post"]}
        },
    }],
)

print(response.output_text)
```

Três observações de quem já rodou esse tipo de configuração.

Primeiro, teste a autenticação com `whoami` antes de qualquer outra coisa. A documentação da OpenAI apresenta `authorization` como um campo de token de acesso OAuth; a chave do Shager é um bearer token, então a primeira chamada já mostra se o cabeçalho chega do jeito que o Shager espera. Se vier um 401 na saída da ferramenta, use o Caminho 3.

Segundo, `create_post` ficou de fora da lista `never` de propósito, então a API devolve um pedido de aprovação antes de executá-lo. Seu código inspeciona os argumentos e responde com uma resposta de aprovação. É um ponto de controle barato, humano ou por regra, antes de o rascunho ser escrito.

Terceiro, não dê `publish` a essa chave. Assim, mesmo uma chamada aprovada só consegue criar rascunhos.

## Caminho 3: o ChatGPT escreve, seu script entrega

Este é o padrão mais comum entre agências que vivem no ChatGPT. O modelo faz aquilo em que é bom, que é escrever quarenta variações de uma legenda. Um script de vinte linhas faz a entrega pela API REST do Shager em https://app.shager.ai/api/v1, descrita por completo no [documento OpenAPI](https://app.shager.ai/api/v1/openapi.json).

Peça ao ChatGPT uma saída estruturada que você possa colar num arquivo:

```text
For each account below, write a caption for our Saturday walk-in hours post.
Vary the opening line and mention the town. Keep facts identical.
Return only JSON: [{"channel_id": "...", "caption": "..."}]
Accounts: <paste the id and name list from list_channels>
```

Depois, envie como rascunho:

```python
import json, os, requests

API = "https://app.shager.ai/api/v1"
H = {"Authorization": f"Bearer {os.environ['SHAGER_API_KEY']}"}
WS = os.environ["SHAGER_WORKSPACE_ID"]

captions = json.load(open("captions.json"))

r = requests.post(f"{API}/workspaces/{WS}/posts", headers=H, json={
    "caption": captions[0]["caption"],
    "channel_ids": [c["channel_id"] for c in captions],
    "per_channel": captions,
    "cta_url": "https://cedarclinics.example/walk-in",
    "campaign": "walk-in-sat",
    "first_comment": "Hours and directions: https://cedarclinics.example/walk-in",
}, timeout=60)

body = r.json()
if not r.ok:
    raise SystemExit(f"{body['error']['code']}: {body['error']['message']}")
print("draft", body["data"]["id"], body["data"]["status"])
```

O array `per_channel` aceita objetos com `channel_id` e `caption` (além de `first_comment` e `format`, opcionais), então o JSON do ChatGPT entra direto. O `cta_url` ganha um link curto e uma UTM separados para cada conta, com `utm_content` indicando a conta, e é isso que permite atribuir os resultados depois.

## Qual caminho combina com qual equipe?

| Situação | Caminho |
|---|---|
| Você quer hoje um agente com ferramentas num terminal ou numa IDE | Codex com `bearer_token_env_var` |
| Você está construindo seu próprio produto ou agente sobre modelos da OpenAI | Responses API com a ferramenta `mcp`, ou REST simples |
| Sua equipe escreve no ChatGPT e não vai sair de lá | ChatGPT para as legendas, script para a entrega |
| Você quer o Shager dentro do próprio app do ChatGPT | Um conector personalizado no modo desenvolvedor, com login via OAuth |

## O que o login oferece?

Você adiciona https://app.shager.ai/api/mcp como servidor MCP personalizado no ChatGPT e entra com a sua conta do Shager, do jeito que o [guia da OpenAI para conectar a partir do ChatGPT](https://developers.openai.com/apps-sdk/deploy/connect-chatgpt) descreve para servidores com autenticação. Cada pessoa se conecta com a própria conta, em vez de compartilhar uma chave. O registro de auditoria funciona do mesmo jeito, e as ferramentas também, que correspondem uma a uma às operações REST.

## Perguntas frequentes

### Existe algum jeito de usar uma chave de API nas configurações de conector do ChatGPT?

Não, segundo o guia de autenticação da OpenAI para apps no ChatGPT, que lista os modos com OAuth e sem autenticação e diz que o ChatGPT não consegue enviar chaves de API personalizadas. Você não precisa de uma: escolha OAuth e entre com a sua conta. Trate qualquer gambiarra que exponha sua chave atrás de um endpoint aberto como um problema de segurança, e não como solução.

### O Shager funciona no ChatGPT no celular?

Depende de onde o ChatGPT permite servidores MCP personalizados, o que é uma decisão da OpenAI e já mudou durante a implantação. Consulte a documentação atual da OpenAI em vez de confiar no que ela fazia antes.

### Preciso de um plano pago do Shager para testar algum desses caminhos?

Não. O acesso por API e MCP está incluído em todos os planos e, durante o período de lançamento, o Shager é gratuito, sem cartão; antes de começarmos a cobrar, vamos avisar com antecedência. A [página de preços](/en/pricing) mostra os limites de contas de cada plano.

## Próximo passo

Se você vai pelo caminho do código, o jeito mais rápido de se situar é o [guia rápido da API REST](/en/blog/shager-rest-api-quickstart), que vai de uma chave nova a um rascunho rastreável para várias contas em seis chamadas.

---
Source: https://shager.ai/pt/blog/shager-and-chatgpt