# Novidades
Fonte: https://wire.ia.br/documentation/ajuda/novidades
> O que mudou em cada versão. Mudanças que afetam a API aparecem aqui primeiro.
## 0.6 · outubro de 2026 [#06--outubro-de-2026]
### No app [#no-app]
* **Pastas.** Crie pastas e pastas dentro de pastas. No Google Drive, viram pastas de verdade.
* **Importar `.md`.** Arraste notas soltas, pastas ou `.zip` para a barra lateral, para uma pasta ou para dentro de uma página. Imagens citadas vêm junto.
* **Modo leitura.** Botão Ler no topo da página, ou Ctrl Shift L. O Paper lembra a escolha de cada página.
* **Compartilhar por link.** Com validade, modo ao vivo e versões em texto puro (`.md` e `.json`) para IAs.
* **Menu da página.** Ícone, duplicar, mover e copiar link interno.
* **Modelos** para páginas vazias: reunião, projeto, tarefas, leitura, estudo e semana.
* **Guias** no lugar das páginas de exemplo em contas novas.
* **Sincronização estável.** A conexão com o Google fica guardada no aparelho e se renova sozinha. Basta conectar uma vez por aparelho.
### API [#api]
* Primeira versão da [API pessoal](/api/visao-geral): cofres, páginas, busca, anexos e agenda.
* [Modo desenvolvedor](/api/modo-desenvolvedor) e [tokens de acesso](/api/tokens), com o token seguro para IA.
* [Termos da API](/termos/termos-da-api), versão de 2 de outubro de 2026.
* Mapa da documentação para agentes em [`/documentation/agents/raw.json`](https://wire.ia.br/documentation/agents/raw.json).
### Moderação [#moderação]
* Páginas de [suporte](https://wire.ia.br/suporte/) e de [apelação](https://wire.ia.br/apelacao/).
## 0.5 · setembro de 2026 [#05--setembro-de-2026]
* Grupos com edição ao vivo e criptografia de ponta a ponta, amizades por ID ou convite.
* Páginas protegidas por senha, anexos, tabelas, quadros, cronogramas e gráficos.
* Cofres separados e um mapa das ideias mais simples.
# Suporte
Fonte: https://wire.ia.br/documentation/ajuda/suporte
> Como falar com o Paper e o que mandar para a resposta vir mais rápido.
O formulário de suporte fica em [wire.ia.br/suporte](https://wire.ia.br/suporte/). Não precisa estar conectado. Se preferir e-mail, escreva para [contato.brennoleon@gmail.com](mailto:contato.brennoleon@gmail.com).
## Assuntos [#assuntos]
| Assunto | Para quê |
| ------------------------------- | --------------------------------------------------- |
| Dúvida sobre como usar | Algo que esta documentação não respondeu |
| Algo não funciona | Erros, sincronização parada, botão que não responde |
| Minha conta e meus dados (LGPD) | Pedir cópia, correção ou exclusão dos seus dados |
| API e tokens de acesso | Dúvidas sobre a API, limites, casos de uso |
| Denunciar uma nota publicada | Link público com conteúdo que viola os termos |
| Outro assunto | Sugestões e o resto |
## Para a resposta vir mais rápido [#para-a-resposta-vir-mais-rápido]
* Diga o aparelho e o navegador (por exemplo, "Android, Chrome").
* Para problemas, conte o passo a passo até o erro e copie a mensagem que apareceu.
* Para a API, mande o código de resposta e a mensagem de erro. **Nunca mande o token.** Os 8 caracteres do meio (`paper_k3m9x2ab_…`) bastam para achar o token.
## Conta banida [#conta-banida]
Use a [apelação](https://wire.ia.br/apelacao/). Veja [Banimento e apelação](/termos/banimento-e-apelacao).
## Antes de escrever [#antes-de-escrever]
* A sincronização pediu para conectar? Veja [Sincronizar com o Google Drive](/guia/sincronizar).
* A API respondeu um erro? Veja [Erros](/api/erros).
# Agenda
Fonte: https://wire.ia.br/documentation/api/agenda
> Ler, criar e apagar eventos na agenda "Paper" do Google Agenda.
A API mexe só na agenda chamada **Paper**, que o próprio app cria no Google Agenda da pessoa. As outras agendas dela ficam fora de alcance.
Antes de usar:
1. A pessoa conecta o Google Agenda em **Configurações → Integrações**.
2. Em **Configurações → Desenvolvedor**, toca em **Liberar a agenda "Paper" para a API**.
3. O token precisa da permissão de agenda. Tokens seguros não acessam a agenda.
Sem os dois primeiros passos, a API responde `409`.
## Listar eventos [#listar-eventos]
```http
GET /calendar/events?from=2026-10-01&to=2026-10-31
```
`from` e `to` aceitam data ou data e hora em ISO 8601. Sem `from`, começa agora. Sem `to`, vai até 30 dias depois de `from`. Devolve até 250 eventos, em ordem de início.
```json
[
{
"id": "k9d8f7g6h5j4",
"titulo": "Dentista",
"descricao": null,
"inicio": { "dateTime": "2026-10-06T14:00:00-03:00", "timeZone": "America/Sao_Paulo" },
"fim": { "dateTime": "2026-10-06T15:00:00-03:00", "timeZone": "America/Sao_Paulo" }
}
]
```
Eventos de dia inteiro vêm com `{ "date": "2026-10-06" }` em `inicio` e `fim`.
## Criar um evento [#criar-um-evento]
```http
POST /calendar/events
Content-Type: application/json
```
```json
{
"title": "Entregar relatório",
"date": "2026-10-08",
"time": "09:30",
"durationMinutes": 45,
"description": "Versão final, com os gráficos.",
"timeZone": "America/Sao_Paulo"
}
```
| Campo | Obrigatório | Regras |
| ----------------- | ----------- | ------------------------------------------------ |
| `title` | Não | Até 300 caracteres. Vazio vira "Evento". |
| `date` | Sim | `AAAA-MM-DD`. |
| `time` | Não | `HH:MM`. Sem horário, o evento é de dia inteiro. |
| `durationMinutes` | Não | De 5 a 1440. Padrão: 60. |
| `description` | Não | Até 4000 caracteres. |
| `timeZone` | Não | Fuso IANA. Padrão: `America/Sao_Paulo`. |
Resposta: `{ "id": "…" }`. Precisa da permissão **Ler e criar eventos**.
## Apagar um evento [#apagar-um-evento]
```http
DELETE /calendar/events/{id}
```
Só apaga eventos da agenda "Paper". Precisa da permissão **Ler e criar eventos**.
## Bom senso [#bom-senso]
Crie eventos que a pessoa pediu ou que vêm das notas dela. Não encha a agenda com lembretes repetidos nem use a agenda como fila de tarefas de um sistema.
# Agentes de IA
Fonte: https://wire.ia.br/documentation/api/agentes-de-ia
> Regras e roteiro para uma IA usar o caderno de alguém com cuidado.
Esta página fala direto com agentes de IA. Se você é uma pessoa configurando um agente, mande para ele o texto do botão **Copiar instruções para a IA** e o link do mapa:
```txt
https://wire.ia.br/documentation/agents/raw.json
```
## Roteiro [#roteiro]
**Confirme quem você atende.** Chame `GET /api/v1/me` com `Authorization` e `X-Paper-Account`. Se a conta não bater, pare e avise a pessoa.
**Veja o que pode.** A resposta de `/me` traz o tipo do token e as permissões. `GET /vaults` mostra os cofres que você alcança. Se o cofre tem id começando com `copia-`, você trabalha numa cópia e a pessoa revisa tudo depois.
**Leia antes de escrever.** Liste as páginas, leia as que importam para o pedido. Guarde a lista em memória durante a tarefa em vez de pedir de novo a cada passo.
**Mude o mínimo.** Prefira `append` a reescrever a página inteira. Ao reescrever, preserve o que a pessoa escreveu e o formato dos blocos (veja [Formato das páginas](/api/formato-das-paginas)).
**Conte o que fez.** No fim, diga à pessoa quais páginas criou, mudou ou mandou para a lixeira, com os títulos.
## Faça [#faça]
* Respeite as permissões. `403` quer dizer não: não tente outro caminho.
* Trate páginas protegidas (`423`) como fechadas. Não peça a senha à pessoa e não tente adivinhar o conteúdo.
* Em `429`, pare, espere e volte num ritmo menor. Veja [Limites](/api/limites).
* Escreva em português claro, como a pessoa escreve. Use os blocos do Paper quando ajudarem: tarefas com `@data`, tabelas, quadros.
* Crie uma pasta para o que você produzir, se a pessoa não disse onde pôr.
## Não faça [#não-faça]
* Não use o caderno como memória de longo prazo sua, banco de dados, fila de tarefas ou log de execução.
* Não envie arquivos para hospedar em outro lugar.
* Não consulte em laço para saber se algo mudou. Uma checagem por minuto, no máximo.
* Não copie o conteúdo do caderno para fora da conversa com a pessoa sem ela pedir.
* Não mostre o token em respostas, logs ou arquivos.
* Não apague em massa. Para mais de 10 páginas de uma vez, peça confirmação.
Quebrar essas regras leva ao banimento permanente da conta da pessoa que confiou o token a você. Os termos completos estão em [Termos da API](/termos/termos-da-api).
## Instruções de exemplo [#instruções-de-exemplo]
```txt
Você tem acesso ao meu caderno do Paper pela API pessoal.
Token (envie no cabeçalho Authorization: Bearer): paper_…
Minha conta: 3f2a… (envie também no cabeçalho X-Paper-Account)
Base da API: https://wire.ia.br/api/v1
Leia primeiro o mapa da documentação: https://wire.ia.br/documentation/agents/raw.json
Respeite os limites e os termos de uso da API descritos lá. Use o caderno como caderno, não como banco de dados.
```
## Ferramentas para o agente [#ferramentas-para-o-agente]
Se o seu agente aceita ferramentas definidas por você, estas cinco cobrem quase tudo:
| Ferramenta | Pedido |
| -------------------------------------------- | ----------------------------------------------- |
| `listar_paginas(cofre)` | `GET /vaults/{cofre}/pages` |
| `ler_pagina(cofre, id)` | `GET /vaults/{cofre}/pages/{id}?format=md` |
| `buscar(cofre, texto)` | `GET /vaults/{cofre}/search?q=` |
| `criar_pagina(cofre, titulo, texto, pasta?)` | `POST /vaults/{cofre}/pages` |
| `acrescentar(cofre, id, texto)` | `PATCH /vaults/{cofre}/pages/{id}` com `append` |
Exemplos prontos em [Exemplos](/api/exemplos).
# Anexos
Fonte: https://wire.ia.br/documentation/api/anexos
> Enviar imagens e arquivos que fazem parte das notas.
```http
POST /vaults/{cofre}/files?name={arquivo.ext}
Content-Type: image/png
(corpo: os bytes do arquivo)
```
O arquivo vai para a pasta **Anexos** do cofre, no Google Drive da pessoa. A resposta traz o Markdown pronto para pôr numa página:
```json
{ "ref": "a3f9c21b7e-grafico.png", "markdown": "" }
```
Imagens voltam como ``. Outros arquivos voltam como link `[📎 nome](Anexos/ref)`.
## Exemplo [#exemplo]
```bash
curl -X POST "https://wire.ia.br/api/v1/vaults/principal/files?name=grafico.png" \
-H "Authorization: Bearer $PAPER_TOKEN" \
-H "X-Paper-Account: $PAPER_CONTA" \
-H "Content-Type: image/png" \
--data-binary @grafico.png
```
Depois, acrescente o Markdown numa página:
```bash
curl -X PATCH "https://wire.ia.br/api/v1/vaults/principal/pages/pa1k2m3n4o5p" \
-H "Authorization: Bearer $PAPER_TOKEN" \
-H "Content-Type: application/json" \
-d '{"append": ""}'
```
## Regras [#regras]
| Regra | Valor |
| -------------- | -------------------------------------------------------------- |
| Permissão | Token normal com "Enviar arquivos" e **Ler e editar** no cofre |
| Tamanho máximo | 10 MB por arquivo |
| Quantidade | 30 envios por dia, por token |
| Cópias para IA | Não recebem arquivos |
## Para que serve, e para que não serve [#para-que-serve-e-para-que-não-serve]
Anexos existem para as notas da pessoa: a foto do quadro da reunião, o PDF que a página comenta, o gráfico que um script gerou para um relatório.
Não use o Paper para hospedar imagens ou arquivos que outros sites, apps ou pessoas vão baixar. Isso inclui usar links publicados como CDN. Abuso de hospedagem leva a banimento permanente. Veja [Uso justo](/termos/uso-justo).
Hospedagem de imagens na nuvem para o plano pago é um recurso futuro e ainda não existe.
# Autenticação
Fonte: https://wire.ia.br/documentation/api/autenticacao
> O cabeçalho do token e a confirmação de conta com o ID.
Todo pedido leva o token no cabeçalho `Authorization`:
```http
GET /api/v1/vaults HTTP/1.1
Host: wire.ia.br
Authorization: Bearer paper_k3m9x2ab_Q7wLc2…
X-Paper-Account: 3f2a9c…(ID da conta, 32 caracteres)
```
## Confirmação de conta [#confirmação-de-conta]
O cabeçalho `X-Paper-Account` é opcional e recomendado. Ele leva o ID da conta dona do token, que aparece em **Configurações → Desenvolvedor** e em **Configurações → Perfil**.
Se o ID não bater com o dono do token, o pedido falha com `403`, sem tocar em nada. Isso evita que um agente use, por engano, o token de outra pessoa que ficou no histórico, num arquivo antigo ou na conversa errada.
Agentes de IA devem sempre mandar esse cabeçalho.
## O que é conferido em cada pedido [#o-que-é-conferido-em-cada-pedido]
1. O formato do token.
2. Se o token existe, não foi revogado e não venceu (`401` se falhar).
3. Se a conta existe, não está banida e está com o modo desenvolvedor ligado (`403` se falhar).
4. Se `X-Paper-Account` bate com a conta (`403` se falhar).
5. Os limites por minuto e por dia (`429` se passar). Veja [Limites](/api/limites).
6. Se o token tem permissão para o cofre, a agenda ou os anexos do pedido (`403` se faltar).
## Boas práticas [#boas-práticas]
* Use sempre `https://`. Um pedido em `http://` é redirecionado, mas o token já viajou sem proteção.
* Não mande o token em parâmetro de URL. Ele aparece em logs e históricos.
* Guarde o token fora do código: variável de ambiente, gerenciador de segredos ou cofre de senhas.
# Busca
Fonte: https://wire.ia.br/documentation/api/busca
> Procurar páginas por título e texto dentro de um cofre.
```http
GET /vaults/{cofre}/search?q={texto}
```
Procura no título e no texto das páginas do cofre. Devolve até 50 resultados. O texto da busca pode ter até 100 caracteres.
```bash
curl "https://wire.ia.br/api/v1/vaults/principal/search?q=or%C3%A7amento" \
-H "Authorization: Bearer $PAPER_TOKEN" \
-H "X-Paper-Account: $PAPER_CONTA"
```
## Resposta com token normal [#resposta-com-token-normal]
A busca roda no Google Drive da pessoa e devolve as páginas encontradas:
```json
[
{ "id": "pa1k2m3n4o5p", "title": "Reunião de segunda", "kind": "pagina", "updatedAt": "2026-10-01T14:03:11.000Z" }
]
```
Para ler o texto, peça a página com `GET /vaults/{cofre}/pages/{id}`.
## Resposta com token seguro [#resposta-com-token-seguro]
Na cópia para IA, cada resultado já vem com um trecho em volta do que foi encontrado:
```json
[
{ "id": "pa1k2m3n4o5p", "title": "Reunião de segunda", "trecho": "…revisar o orçamento antes da reunião com…" }
]
```
## Dicas [#dicas]
* Codifique o texto na URL (`encodeURIComponent` em JavaScript, `urllib.parse.quote` em Python).
* Para varrer o cofre inteiro, liste as páginas uma vez e guarde o resultado. Não faça uma busca por página.
* Páginas protegidas nunca aparecem com conteúdo. Com a permissão "Mostrar só o título", podem aparecer na lista de resultados pelo título.
# Cofres e páginas
Fonte: https://wire.ia.br/documentation/api/cofres-e-paginas
> Listar cofres, listar e ler páginas, criar, editar e mandar para a lixeira.
Todos os caminhos começam em `https://wire.ia.br/api/v1`. Os exemplos usam `$PAPER_TOKEN` e `$PAPER_CONTA` como variáveis de ambiente.
## Listar cofres [#listar-cofres]
```http
GET /vaults
```
Devolve só os cofres que o token alcança. Com token normal, só aparecem cofres sincronizados com o Google Drive. Com token seguro, aparece só a cópia dele.
```json
[
{ "id": "principal", "nome": "Meu caderno", "acesso": "editar", "copia": false },
{ "id": "cmg2k1x9a4tz", "nome": "Trabalho", "acesso": "ler", "copia": false }
]
```
O cofre principal sempre tem o id `principal`. Cópias para IA têm ids no formato `copia-` seguido de 16 caracteres.
## Listar páginas [#listar-páginas]
```http
GET /vaults/{cofre}/pages
GET /vaults/{cofre}/pages?parent={id}
GET /vaults/{cofre}/pages?parent=
```
Sem `parent`, devolve todas as páginas e pastas do cofre. Com `parent={id}`, só as que estão dentro daquela página ou pasta. Com `parent=` vazio, só as da raiz.
```json
[
{ "id": "pa1k2m3n4o5p", "title": "Reunião de segunda", "parentId": null, "kind": "pagina", "updatedAt": "2026-10-01T14:03:11.000Z" },
{ "id": "pb7q8r9s0t1u", "title": "Projetos", "parentId": null, "kind": "pasta", "updatedAt": "2026-09-28T10:00:00.000Z" }
]
```
| Campo | O que é |
| ----------- | -------------------------------------------------------------------------------------------- |
| `id` | Id da página. É o mesmo no app, no Drive e na API. |
| `title` | Título. |
| `parentId` | Página ou pasta onde ela está. `null` na raiz. |
| `kind` | `pagina` (tem texto) ou `pasta` (só agrupa). |
| `updatedAt` | Última mudança, em ISO 8601. |
| `locked` | `true` em páginas protegidas. Elas só aparecem na lista se o token puder ver o título delas. |
## Ler uma página [#ler-uma-página]
```http
GET /vaults/{cofre}/pages/{id}
GET /vaults/{cofre}/pages/{id}?format=md
```
```json
{
"id": "pa1k2m3n4o5p",
"title": "Reunião de segunda",
"parentId": null,
"kind": "pagina",
"updatedAt": "2026-10-01T14:03:11.000Z",
"markdown": "## Pauta\n\n- [ ] Revisar orçamento @2026-10-06 10:00\n- [x] Mandar ata",
"props": { "tags": "trabalho" }
}
```
Com `?format=md`, a resposta é só o texto em Markdown (`text/markdown`), começando pelo título. Bom para colar direto numa IA.
`props` traz as propriedades do frontmatter da página. O formato do Markdown está em [Formato das páginas](/api/formato-das-paginas).
Página protegida por senha responde `423`, sempre.
## Criar uma página ou pasta [#criar-uma-página-ou-pasta]
```http
POST /vaults/{cofre}/pages
Content-Type: application/json
```
```json
{
"title": "Ideias para o fim de semana",
"markdown": "- Trilha no sábado\n- [ ] Comprar pão",
"parentId": "pb7q8r9s0t1u",
"kind": "pagina"
}
```
| Campo | Obrigatório | Regras |
| ---------- | ----------- | -------------------------------------------- |
| `title` | Não | Até 200 caracteres. Vazio vira "Sem título". |
| `markdown` | Não | Até 1 MB. Ignorado em pastas. |
| `parentId` | Não | Id de uma página ou pasta do mesmo cofre. |
| `kind` | Não | `pagina` (padrão) ou `pasta`. |
Resposta:
```json
{ "id": "pc2v3w4x5y6z", "title": "Ideias para o fim de semana", "kind": "pagina" }
```
Precisa de permissão **Ler e editar** no cofre. A página aparece no app da pessoa na próxima sincronização.
## Editar uma página [#editar-uma-página]
```http
PATCH /vaults/{cofre}/pages/{id}
Content-Type: application/json
```
Mande um ou mais destes campos:
| Campo | O que faz |
| ---------- | ------------------------------------------------------- |
| `title` | Troca o título. |
| `markdown` | Troca o texto inteiro. |
| `append` | Acrescenta texto no fim, depois de uma linha em branco. |
```json
{ "append": "## Atualização\n\nO orçamento foi aprovado." }
```
Prefira `append` sempre que der. Ele não apaga nada que a pessoa escreveu enquanto o seu programa trabalhava.
Pastas não têm texto: `PATCH` numa pasta com `markdown` ou `append` responde `400`.
## Mandar para a lixeira [#mandar-para-a-lixeira]
```http
DELETE /vaults/{cofre}/pages/{id}
```
```json
{ "ok": true, "lixeira": true }
```
A página vai para a lixeira do Google Drive da pessoa, e dá para recuperar de lá. Em cópias para IA, a página fica marcada como apagada até a pessoa revisar.
## Quando o app vê as mudanças [#quando-o-app-vê-as-mudanças]
Com token normal, a mudança vai direto para o Google Drive. O app da pessoa traz na próxima sincronização, que acontece ao abrir o app, ao voltar para a aba e de tempos em tempos. Se a pessoa mexeu na mesma página no aparelho ao mesmo tempo, nada se perde: uma das versões vira uma cópia "(outra versão)".
# Cópias para IA
Fonte: https://wire.ia.br/documentation/api/copias-para-ia
> Como funciona o token seguro, a cópia isolada de um cofre e a revisão das mudanças.
O token seguro existe para você entregar um cofre a uma IA sem arriscar o original. A IA trabalha numa cópia; você decide o que volta.
## Como funciona [#como-funciona]
**Você cria o token seguro** em Configurações → Desenvolvedor e escolhe um cofre. O app manda uma cópia do texto das páginas desse cofre para o servidor. Páginas protegidas por senha ficam de fora.
**A IA usa a API normalmente.** `GET /vaults` mostra um único cofre, com id `copia-` e 16 caracteres. Ela lista, lê, busca, cria, edita e apaga páginas nessa cópia.
**Você revisa.** Em **Cópias para IA**, o app mostra quantas mudanças estão esperando. **Revisar mudanças** lista cada página nova, editada ou apagada, com o texto que a IA deixou.
**Você escolhe o que trazer.** Com o cofre original aberto no app, marque as mudanças que quer e toque em **Trazer para o cofre**. Elas entram no seu aparelho e sobem para o Drive na sincronização seguinte. Ctrl Z desfaz. **Descartar selecionadas** tira as mudanças da lista sem mexer no seu cofre.
## Para quem programa a IA [#para-quem-programa-a-ia]
Nada muda na forma de chamar a API. Use o id da cópia onde iria o id do cofre:
```bash
COFRE=$(curl -s https://wire.ia.br/api/v1/vaults \
-H "Authorization: Bearer $PAPER_TOKEN" | jq -r '.[0].id')
curl "https://wire.ia.br/api/v1/vaults/$COFRE/pages" \
-H "Authorization: Bearer $PAPER_TOKEN"
```
Diferenças em relação ao token normal:
* A busca devolve um trecho do texto junto com cada resultado.
* Não envia arquivos nem mexe na agenda (`403` ou `400`).
* A cópia aceita até 6000 páginas. O cofre original precisa ter até 20 MB de texto para ser copiado.
* Mudanças que a pessoa faz no cofre original depois da cópia não aparecem para a IA. Para dar a versão nova, a pessoa cria outro token seguro.
## O que fica guardado [#o-que-fica-guardado]
A cópia fica no servidor do Paper, em texto aberto, enquanto o token existir. Ela é apagada quando a pessoa revoga o token ou desliga o modo desenvolvedor. Revisar não apaga a cópia: a IA pode continuar trabalhando nela. Isso está na [política de privacidade](https://wire.ia.br/privacidade/).
## Diga isso à IA [#diga-isso-à-ia]
Se a IA sabe que trabalha numa cópia, ela fica mais à vontade para reorganizar e você fica com a palavra final. O botão **Copiar instruções para a IA**, que aparece quando você cria o token, já monta um texto com o token, o ID da conta, a base da API e o link do [mapa da documentação](https://wire.ia.br/documentation/agents/raw.json).
# Erros
Fonte: https://wire.ia.br/documentation/api/erros
> Os códigos de resposta e o que fazer com cada um.
Todo erro volta em JSON, com uma mensagem em português que pode ser mostrada para a pessoa:
```json
{ "error": "Este token só pode ler este cofre." }
```
| Código | Quando acontece | O que fazer |
| ------ | ------------------------------------------------------------------------------------------------------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------- |
| `400` | Faltou um campo ou o formato está errado | Corrija o pedido. A mensagem diz o quê. |
| `401` | Token ausente, mal formado, inválido, revogado ou vencido | Peça um token novo à pessoa. Não tente de novo com o mesmo. |
| `403` | Sem permissão para o cofre, a agenda ou os anexos; conta diferente da informada em `X-Paper-Account`; modo desenvolvedor desligado; conta banida | Não insista. Avise a pessoa do que falta. |
| `404` | Cofre ou página não encontrados | Confira os ids com `GET /vaults` e `GET /vaults/{cofre}/pages`. Cofres precisam estar sincronizados com o Google Drive. |
| `409` | O Google ou a agenda não foram liberados para a API, ou a pessoa revogou o acesso no Google | A pessoa precisa abrir o app e liberar de novo em Configurações → Desenvolvedor. |
| `413` | Arquivo ou texto grande demais | Divida ou reduza. Veja [Limites](/api/limites). |
| `423` | Página protegida por senha | Deixe a página em paz. Nenhum token abre. |
| `429` | Limite de pedidos ou de envios | Espere e tente de novo, com intervalos crescentes. |
| `500` | Erro do nosso lado | Tente de novo em alguns minutos. Se repetir, avise o [suporte](https://wire.ia.br/suporte/). |
| `502` | O Google Drive ou o Google Agenda falharam | Tente de novo mais tarde. |
| `503` | Serviço em manutenção | Tente de novo mais tarde. |
## Tentar de novo [#tentar-de-novo]
Só vale tentar de novo em `429`, `500`, `502` e `503`. Use intervalos crescentes e um teto de tentativas. Os outros códigos não mudam sozinhos.
# Exemplos
Fonte: https://wire.ia.br/documentation/api/exemplos
> Código pronto em curl, JavaScript e Python, do primeiro pedido a uma automação completa.
Todos os exemplos leem o token e o ID da conta de variáveis de ambiente:
```bash
export PAPER_TOKEN="paper_…"
export PAPER_CONTA="3f2a…"
```
## Um cliente mínimo [#um-cliente-mínimo]
```js
// Node 18+ ou navegador. Sem dependências.
const BASE = 'https://wire.ia.br/api/v1';
async function paper(path, { method = 'GET', body, tentativas = 4 } = {}) {
for (let i = 0; ; i++) {
const res = await fetch(BASE + path, {
method,
headers: {
Authorization: `Bearer ${process.env.PAPER_TOKEN}`,
'X-Paper-Account': process.env.PAPER_CONTA,
...(body ? { 'Content-Type': 'application/json' } : {}),
},
body: body ? JSON.stringify(body) : undefined,
});
if (res.ok) return res.status === 204 ? null : res.json();
const { error } = await res.json().catch(() => ({ error: res.statusText }));
const vale = [429, 500, 502, 503].includes(res.status) && i < tentativas;
if (!vale) throw new Error(`${res.status}: ${error}`);
await new Promise((r) => setTimeout(r, 2000 * 2 ** i));
}
}
const eu = await paper('/me');
console.log(`Conectado como ${eu.conta.nome}, token ${eu.token.tipo}`);
```
```python
# Python 3.9+. Precisa de: pip install requests
import os, time, requests
BASE = "https://wire.ia.br/api/v1"
SESSAO = requests.Session()
SESSAO.headers.update({
"Authorization": f"Bearer {os.environ['PAPER_TOKEN']}",
"X-Paper-Account": os.environ["PAPER_CONTA"],
})
def paper(caminho, metodo="GET", json=None, tentativas=4):
for i in range(tentativas + 1):
res = SESSAO.request(metodo, BASE + caminho, json=json, timeout=30)
if res.ok:
return res.json() if res.content else None
if res.status_code not in (429, 500, 502, 503) or i == tentativas:
raise RuntimeError(f"{res.status_code}: {res.json().get('error')}")
time.sleep(2 * 2 ** i)
eu = paper("/me")
print(f"Conectado como {eu['conta']['nome']}, token {eu['token']['tipo']}")
```
```bash
paper() {
curl -sS "https://wire.ia.br/api/v1$1" \
-H "Authorization: Bearer $PAPER_TOKEN" \
-H "X-Paper-Account: $PAPER_CONTA" \
-H "Content-Type: application/json" "${@:2}"
}
paper /me
paper /vaults
```
## Criar a página do dia [#criar-a-página-do-dia]
Cria uma página com a data de hoje numa pasta "Diário do script", se ela ainda não existir.
```js
const hoje = new Date().toISOString().slice(0, 10);
const paginas = await paper('/vaults/principal/pages');
let pasta = paginas.find((p) => p.kind === 'pasta' && p.title === 'Diário do script');
if (!pasta) {
pasta = await paper('/vaults/principal/pages', {
method: 'POST',
body: { title: 'Diário do script', kind: 'pasta' },
});
}
if (!paginas.some((p) => p.parentId === pasta.id && p.title === hoje)) {
await paper('/vaults/principal/pages', {
method: 'POST',
body: {
title: hoje,
parentId: pasta.id,
markdown: `## Para hoje\n\n- [ ] \n\n## Anotações\n`,
},
});
}
```
```python
from datetime import date
hoje = date.today().isoformat()
paginas = paper("/vaults/principal/pages")
pasta = next((p for p in paginas if p["kind"] == "pasta" and p["title"] == "Diário do script"), None)
if pasta is None:
pasta = paper("/vaults/principal/pages", "POST", {"title": "Diário do script", "kind": "pasta"})
if not any(p["parentId"] == pasta["id"] and p["title"] == hoje for p in paginas):
paper("/vaults/principal/pages", "POST", {
"title": hoje,
"parentId": pasta["id"],
"markdown": "## Para hoje\n\n- [ ] \n\n## Anotações\n",
})
```
## Acrescentar numa página [#acrescentar-numa-página]
```bash
paper /vaults/principal/pages/pa1k2m3n4o5p -X PATCH \
-d '{"append": "- [ ] Ligar para o fornecedor @2026-10-07 10:00"}'
```
## Ler tudo de uma pasta para uma IA [#ler-tudo-de-uma-pasta-para-uma-ia]
```python
def texto_da_pasta(cofre, pasta_id):
partes = []
for p in paper(f"/vaults/{cofre}/pages?parent={pasta_id}"):
if p["kind"] == "pagina" and not p.get("locked"):
pagina = paper(f"/vaults/{cofre}/pages/{p['id']}")
partes.append(f"# {pagina['title']}\n\n{pagina['markdown']}")
return "\n\n---\n\n".join(partes)
```
Pastas com muitas páginas gastam um pedido por página. Para 60 páginas ou mais, espalhe as leituras ao longo de alguns minutos.
## Criar um evento a partir de uma tarefa [#criar-um-evento-a-partir-de-uma-tarefa]
```js
await paper('/calendar/events', {
method: 'POST',
body: { title: 'Ligar para o fornecedor', date: '2026-10-07', time: '10:00', durationMinutes: 15 },
});
```
## Enviar uma imagem e pôr numa página [#enviar-uma-imagem-e-pôr-numa-página]
```bash
RESPOSTA=$(curl -sS -X POST "https://wire.ia.br/api/v1/vaults/principal/files?name=grafico.png" \
-H "Authorization: Bearer $PAPER_TOKEN" \
-H "X-Paper-Account: $PAPER_CONTA" \
-H "Content-Type: image/png" \
--data-binary @grafico.png)
MD=$(echo "$RESPOSTA" | jq -r .markdown)
paper /vaults/principal/pages/pa1k2m3n4o5p -X PATCH -d "$(jq -n --arg md "$MD" '{append: $md}')"
```
## Ferramenta para um agente (Claude, OpenAI e outros) [#ferramenta-para-um-agente-claude-openai-e-outros]
Uma definição de ferramenta no formato JSON Schema, que a maioria dos modelos aceita:
```json
{
"name": "paper_acrescentar",
"description": "Acrescenta texto em Markdown no fim de uma página do caderno Paper da pessoa.",
"input_schema": {
"type": "object",
"properties": {
"cofre": { "type": "string", "description": "Id do cofre, de GET /vaults" },
"pagina": { "type": "string", "description": "Id da página, de GET /vaults/{cofre}/pages" },
"texto": { "type": "string", "description": "Markdown a acrescentar" }
},
"required": ["cofre", "pagina", "texto"]
}
}
```
Na hora de executar, chame `PATCH /vaults/{cofre}/pages/{pagina}` com `{"append": texto}`.
# Formato das páginas
Fonte: https://wire.ia.br/documentation/api/formato-das-paginas
> O Markdown que a API lê e escreve, com tabelas, quadros, cronogramas, gráficos, datas e links.
Cada página é Markdown comum, legível em qualquer editor. Os blocos que o Markdown não tem viram blocos de código com nomes próprios, e o app transforma de volta em blocos interativos.
## Básico [#básico]
````md
## Título de seção
Texto com **negrito**, *itálico*, ~~riscado~~ e `código`.
- Lista
1. Lista numerada
- [ ] Tarefa aberta
- [x] Tarefa feita
> Citação
> [!nota]
> Destaque (callout)
```js
console.log('bloco de código')
```
---
````
## Ligações, datas e anexos [#ligações-datas-e-anexos]
| Escreva | Vira |
| ----------------------------------------- | ------------------------------------------------- |
| `[[Nome da página]]` | Link para outra página do cofre |
| `[[Nome da página\|texto]]` | Link com outro texto |
| `@2026-10-06` | Data. Numa tarefa, aparece na Agenda do app |
| `@2026-10-06 14:30` | Data com horário |
| `` | Imagem enviada pela [API de anexos](/api/anexos) |
| `#etiqueta` | Etiqueta, que aparece nos filtros da busca do app |
## Tabela [#tabela]
Tabela em Markdown normal. Um comentário opcional antes dela guarda o tipo de cada coluna (`texto`, `numero`, `data`, `check`, `opcao`):
```md
| Tarefa | Prazo | Feita |
| --- | --- | --- |
| Orçamento | 2026-10-06 | sim |
```
## Quadro (Kanban) [#quadro-kanban]
Cada `##` é uma coluna; cada item é um cartão.
````md
```paper-kanban
## A fazer
- [ ] Revisar contrato
## Fazendo
- [ ] Escrever relatório
## Feito
- [x] Marcar reunião
```
````
## Cronograma [#cronograma]
Uma etapa por linha: início, fim e nome.
````md
```paper-cronograma
- [x] 2026-10-01 → 2026-10-05 · Planejar
- [ ] 2026-10-04 → 2026-10-15 · Fazer
- [ ] 2026-10-14 → 2026-10-20 · Revisar
```
````
`->` e `até` também funcionam no lugar de `→`.
## Gráfico [#gráfico]
Tipo (`barras`, `linhas`, `area`, `pizza`), título opcional e uma tabelinha separada por `;`. A primeira linha dá os nomes das séries.
````md
```paper-grafico
tipo: barras
título: Gastos do trimestre
Mês; Mercado; Transporte
Jul; 820; 210
Ago; 790; 180
Set; 845; 230
```
````
## Frontmatter [#frontmatter]
As propriedades da página ficam num bloco `---` no topo do arquivo. A API devolve essas propriedades em `props`, e não precisa que você mande o frontmatter ao criar ou editar: mande só o texto.
## Páginas protegidas [#páginas-protegidas]
No arquivo `.md`, uma página com senha vira um bloco cifrado que só o app abre com a senha. A API não lê nem escreve essas páginas (`423`).
# Limites
Fonte: https://wire.ia.br/documentation/api/limites
> Quantos pedidos, quantos arquivos e de que tamanho.
| Limite | Valor | Vale para |
| ---------------------------- | ----- | --------------------------------- |
| Pedidos por minuto | 60 | Cada token |
| Pedidos por dia | 5000 | Cada token, zera à meia-noite UTC |
| Envios de arquivo por dia | 30 | Cada token |
| Tamanho de um arquivo | 10 MB | Cada envio |
| Texto de uma página | 1 MB | `markdown` e `append` |
| Corpo de um pedido JSON | 2 MB | Cada pedido |
| Tokens ativos | 20 | Cada conta |
| Texto de um cofre para cópia | 20 MB | Token seguro |
| Páginas numa cópia | 6000 | Token seguro |
| Resultados de busca | 50 | Cada busca |
| Eventos por listagem | 250 | Agenda |
Os limites também aparecem em `GET /me`, no campo `limites`.
## Quando passar do limite [#quando-passar-do-limite]
A API responde `429` com uma mensagem dizendo qual limite foi atingido:
```json
{ "error": "Limite de 60 pedidos por minuto. Espere um pouco." }
```
Espere e tente de novo, com intervalos crescentes: 2 segundos, depois 4, 8, 16. Se for o limite do dia, pare até o dia seguinte.
## Uso normal [#uso-normal]
Um uso normal, como um assistente que organiza notas ou um script que cria a página do dia, fica muito abaixo desses números. Contornar limites com vários tokens ou várias contas é violação dos termos e leva a banimento. Veja [Uso justo](/termos/uso-justo).
Se você tem um caso real que precisa de mais, escreva para o [suporte](https://wire.ia.br/suporte/) escolhendo o assunto **API e tokens de acesso**.
# Modo desenvolvedor
Fonte: https://wire.ia.br/documentation/api/modo-desenvolvedor
> O interruptor que libera tokens, envio de arquivos, mudanças na agenda e automações remotas.
O app continua igual com o modo desenvolvedor ligado. Ele só libera os tokens de acesso. Sem ele, nenhum token funciona, mesmo os que já existem.
## Ligar [#ligar]
Abra **Configurações → Desenvolvedor**.
Leia os [termos de uso da API](/termos/termos-da-api), marque a caixa de aceite e toque em **Ligar modo desenvolvedor**.
Copie o ID da sua conta, que aparece no topo. Ele vai no cabeçalho `X-Paper-Account` e confirma que o token é seu. Veja [Autenticação](/api/autenticacao).
## Liberar o Google para a API [#liberar-o-google-para-a-api]
Tokens normais leem e escrevem nos cofres de verdade pelo seu Google Drive. Para isso, o servidor precisa guardar a sua conexão com o Google.
* **Google Drive para a API**: conecte o Google em **Sincronização** e toque em **Liberar a conexão deste aparelho para a API**.
* **Agenda para a API**: conecte o Google Agenda em **Integrações** e toque em **Liberar a agenda "Paper" para a API**.
O servidor age no seu Drive e na sua agenda só quando um token seu é usado. Tokens seguros não precisam de nada disso.
## O que o modo libera [#o-que-o-modo-libera]
| Recurso | Sem o modo | Com o modo |
| ------------------------------------------------- | ------------- | -------------------------- |
| Tokens de acesso | Não funcionam | Até 20 ativos |
| Ler e escrever páginas por programa | Não | Onde o token permitir |
| Enviar arquivos pela API | Não | Até 30 por dia, 10 MB cada |
| Criar e apagar eventos na agenda "Paper" | Não | Se o token permitir |
| Automações remotas (scripts, servidores, agentes) | Não | Sim |
## Desligar [#desligar]
**Desligar modo desenvolvedor** revoga todos os tokens na hora, apaga as cópias para IA e apaga a conexão com o Google guardada no servidor. As suas notas não mudam.
## Conta banida [#conta-banida]
Se a conta for banida por violar os termos, todos os tokens são revogados, os links publicados saem do ar e a conexão com o Google guardada no servidor é apagada. Veja [Banimento e apelação](/termos/banimento-e-apelacao).
# Tokens de acesso
Fonte: https://wire.ia.br/documentation/api/tokens
> Os dois tipos de token, as permissões de cada um e como guardar e revogar.
Um token é uma chave que você entrega para um programa. Ele tem este formato:
```txt
paper_k3m9x2ab_Q7wLc2…(40 caracteres)
```
* `paper_` marca que é um token do Paper. Ferramentas que procuram segredos vazados reconhecem esse começo.
* Os 8 caracteres do meio identificam o token. Eles aparecem na lista de tokens, para você saber qual é qual.
* Os 40 do fim são o segredo. O servidor guarda só um resumo (hash) dele, então nem o Paper consegue mostrar o token de novo. Se perder, revogue e crie outro.
## Os dois tipos [#os-dois-tipos]
| | Seguro (para IA) | Normal |
| ------------------------------------- | ---------------------------------- | --------------------------------------- |
| Para quê | Dar um cofre para uma IA trabalhar | Automações suas |
| O que alcança | Uma cópia isolada de um cofre | Os cofres de verdade, pelo Google Drive |
| Mudanças | Ficam esperando a sua revisão | Valem na hora |
| Agenda e arquivos | Não | Se você permitir |
| Precisa do Google liberado para a API | Não | Sim |
Na dúvida, use o **seguro**. Se a IA errar, o cofre de verdade continua intacto.
## Permissões [#permissões]
Ao criar um token normal, você escolhe:
| Permissão | Opções |
| ------------------ | -------------------------------------------------------------- |
| Cada cofre | Sem acesso, Ler, Ler e editar |
| Páginas protegidas | Esconder (o token nem sabe que existem) ou Mostrar só o título |
| Agenda "Paper" | Sem acesso, Ler eventos, Ler e criar eventos |
| Enviar arquivos | Sim ou não |
| Validade | 7 dias, 30 dias, 90 dias ou sem validade |
Mesmo com "Mostrar só o título", o conteúdo de páginas protegidas nunca sai: o pedido responde `423`.
O token seguro tem permissões fixas: lê e edita só a própria cópia.
## Ver como o token aparece para a API [#ver-como-o-token-aparece-para-a-api]
```bash
curl https://wire.ia.br/api/v1/me -H "Authorization: Bearer $PAPER_TOKEN"
```
```json
{
"conta": { "id": "3f2a…(32 caracteres)", "nome": "Ana" },
"token": {
"id": "k3m9x2ab",
"nome": "Script de tarefas",
"tipo": "normal",
"permissoes": {
"vaults": { "principal": "editar", "cmg2k1x9a4tz": "ler" },
"protegidas": "ocultar",
"agenda": "ler",
"anexos": false
},
"venceEm": "2026-11-01T12:00:00.000Z"
},
"limites": { "perMinute": 60, "perDay": 5000, "uploadsPerDay": 30, "uploadBytes": 10485760, "pageBytes": 1048576 },
"documentacao": "https://wire.ia.br/documentation/agents/raw.json"
}
```
## Guardar com cuidado [#guardar-com-cuidado]
* Guarde em variável de ambiente ou num gerenciador de senhas. Nunca em código público, prints ou mensagens em grupo.
* Um token por programa. Assim, revogar um não derruba os outros.
* Dê só as permissões que o programa precisa.
## Revogar [#revogar]
Em **Configurações → Desenvolvedor → Tokens ativos**, toque em **Revogar**. O token para de funcionar no pedido seguinte. A lista também mostra quando cada token foi usado pela última vez e quantas vezes.
Um token vazado e usado para abuso leva ao banimento da conta dona dele. Se você suspeitar de vazamento, revogue antes de qualquer outra coisa.
# Visão geral da API
Fonte: https://wire.ia.br/documentation/api/visao-geral
> O que a API pessoal faz, para quem ela serve e o caminho mais curto até o primeiro pedido.
A API pessoal deixa um programa ou um agente de IA ler e escrever no caderno de **uma pessoa**, com um token que essa pessoa criou e pode revogar a qualquer momento. Não existe API para ler dados de outras contas, nem acesso de terceiros sem um token.
```txt
Base: https://wire.ia.br/api/v1
Formato: JSON (UTF-8). Arquivos: corpo binário.
Autenticação: Authorization: Bearer paper_…
```
## O caminho mais curto [#o-caminho-mais-curto]
**Ligue o modo desenvolvedor** em Configurações → Desenvolvedor e aceite os [termos da API](/termos/termos-da-api). Veja [Modo desenvolvedor](/api/modo-desenvolvedor).
**Crie um token.** Escolha o tipo (seguro para IA, normal para automações), os cofres e o que ele pode fazer. Veja [Tokens](/api/tokens).
**Faça o primeiro pedido:**
```bash
curl https://wire.ia.br/api/v1/me \
-H "Authorization: Bearer $PAPER_TOKEN" \
-H "X-Paper-Account: $PAPER_CONTA"
```
A resposta mostra a conta, as permissões do token e os limites.
## O que dá para fazer [#o-que-dá-para-fazer]
| Área | Endpoints | Página |
| ---------------- | ---------------------------------------------------------------------------------------------- | ----------------------------------------- |
| Conta | `GET /me` | [Autenticação](/api/autenticacao) |
| Cofres e páginas | `GET /vaults`, `GET/POST /vaults/{cofre}/pages`, `GET/PATCH/DELETE /vaults/{cofre}/pages/{id}` | [Cofres e páginas](/api/cofres-e-paginas) |
| Busca | `GET /vaults/{cofre}/search?q=` | [Busca](/api/busca) |
| Arquivos | `POST /vaults/{cofre}/files?name=` | [Anexos](/api/anexos) |
| Agenda | `GET/POST /calendar/events`, `DELETE /calendar/events/{id}` | [Agenda](/api/agenda) |
## Onde os dados moram [#onde-os-dados-moram]
As notas pessoais não ficam no servidor do Paper. Elas ficam no aparelho da pessoa e no Google Drive dela. Por isso:
* **Token normal**: o servidor lê e escreve no Google Drive da pessoa no momento do pedido, usando a conexão que ela liberou para a API. Só cofres sincronizados com o Drive aparecem.
* **Token seguro**: o servidor guarda uma cópia isolada de um cofre, criada quando a pessoa fez o token. A IA trabalha nessa cópia, e a pessoa decide o que levar para o cofre de verdade. Veja [Cópias para IA](/api/copias-para-ia).
## O que nenhum token faz [#o-que-nenhum-token-faz]
* Abrir páginas protegidas por senha (`423`).
* Ler grupos, que são criptografados de ponta a ponta.
* Mexer na conta, nas sessões, nas amizades ou nas configurações.
## Para agentes de IA [#para-agentes-de-ia]
O mapa completo da documentação, com regras e endpoints, está em [`/documentation/agents/raw.json`](https://wire.ia.br/documentation/agents/raw.json). Antes de agir, leia [Agentes de IA](/api/agentes-de-ia).
# Cofres, pastas e páginas
Fonte: https://wire.ia.br/documentation/guia/cofres-pastas-e-paginas
> Três jeitos de organizar, do maior para o menor.
## Cofres [#cofres]
Um cofre é um caderno inteiro e separado dos outros: páginas, busca, mapa e agenda próprios. Use para separar mundos que não se misturam, como trabalho e vida pessoal.
* Troque de cofre pelo topo da barra lateral.
* Cada cofre sincroniza numa pasta própria dentro da pasta Paper do seu Google Drive.
* Todo caderno começa com o cofre **principal**.
## Pastas [#pastas]
Pastas guardam páginas e outras pastas. Uma pasta não tem texto: ao abrir, ela mostra o que tem dentro, com botões para criar página, criar pasta e importar arquivos `.md` ali mesmo.
* **Criar**: botão de pasta no topo da barra lateral, ou **Nova pasta** dentro de outra pasta.
* **Mover**: arraste na barra lateral, ou use **Mover** no menu da página.
* **No Google Drive**: cada pasta do Paper vira uma pasta de verdade, com os arquivos das páginas dentro.
## Páginas dentro de páginas [#páginas-dentro-de-páginas]
Uma página também pode ter páginas dentro dela, como capítulos. A diferença para a pasta é que a página mãe tem texto próprio.
| Quero… | Use |
| ---------------------------------- | ------------------------- |
| Separar trabalho e vida pessoal | Cofres |
| Agrupar várias páginas por assunto | Pasta |
| Um documento com capítulos | Página com páginas dentro |
## Favoritas, Caixa de entrada e Diário [#favoritas-caixa-de-entrada-e-diário]
* **Favoritas** ficam no topo da barra lateral. Use a estrela no topo da página.
* **Caixa de entrada** recebe o que você anota rápido com Ctrl Shift Espaço.
* **Hoje** abre a página do dia, dentro da pasta Diário.
# Comece por aqui
Fonte: https://wire.ia.br/documentation/guia/comece-por-aqui
> Os primeiros dez minutos no Paper, passo a passo e sem termos técnicos.
Quando você cria a conta, o caderno já vem com a página **Comece por aqui** e uma pasta **Guias**. Elas repetem o que está nesta página, dentro do próprio app. Pode apagar quando quiser: os guias continuam em **Configurações → Sobre → Guias**.
### Escreva [#escreva]
Clique em qualquer linha e escreva. Enter cria uma linha nova. Não existe botão de salvar: o Paper salva sozinho, neste aparelho, mesmo sem internet.
### Escolha o tipo de linha com a barra / [#escolha-o-tipo-de-linha-com-a-barra-]
Numa linha vazia, digite `/` e escolha: título, lista, tarefa, citação, destaque, tabela, quadro, cronograma, gráfico, imagem ou arquivo.
### Ligue uma página na outra [#ligue-uma-página-na-outra]
Escreva `[[` e o nome de uma página. O link acompanha a página quando você muda o nome dela. No fim de cada página aparece onde ela foi mencionada.
### Coloque datas [#coloque-datas]
Escreva `@` e uma data, como `@amanhã 14h`. A linha aparece na **Agenda** e no dia certo.
### Organize em pastas [#organize-em-pastas]
Na barra lateral, o botão de pasta cria uma pasta nova. Arraste páginas para dentro dela. Pastas podem ficar dentro de pastas.
### Leve para outros aparelhos [#leve-para-outros-aparelhos]
Em **Configurações → Sincronização**, conecte o Google Drive uma vez. Cada página vira um arquivo na pasta Paper do seu Drive, e o celular e o computador ficam iguais. Veja [Sincronizar com o Google Drive](/guia/sincronizar).
## Atalhos que valem a pena [#atalhos-que-valem-a-pena]
| Atalho | O que faz |
| ----------------- | --------------------------------------------- |
| Ctrl K | Buscar qualquer coisa |
| Ctrl Z | Desfazer, até apagar uma página |
| Ctrl Shift Espaço | Anotar rápido, sem escolher página |
| Ctrl Shift L | Alternar entre ler e editar |
| Esc | Selecionar o bloco; Shift ↑↓ seleciona vários |
No Mac, troque Ctrl por Cmd.
## Anotar rápido [#anotar-rápido]
Ctrl Shift Espaço abre uma caixinha para anotar sem pensar onde guardar. Tudo cai na **Caixa de entrada**, e você organiza depois.
## Próximos passos [#próximos-passos]
* [Escrever e ler](/guia/escrever-e-ler): os blocos, o modo leitura e os modelos de página.
* [Cofres, pastas e páginas](/guia/cofres-pastas-e-paginas): como separar trabalho, estudo e vida pessoal.
* [Privacidade e segurança](/guia/privacidade-e-seguranca): páginas com senha e o que o Paper enxerga.
# Compartilhar uma página
Fonte: https://wire.ia.br/documentation/guia/compartilhar
> Links públicos de leitura, com versão em texto puro para IAs e programas.
O botão **Compartilhar** no topo da página cria um link para ela. Quem abre o link vê só aquela página, em modo leitura, sem precisar de conta.
## Opções [#opções]
* **Validade**: 1 dia, 7 dias, 30 dias ou sem prazo.
* **Ao vivo**: o link acompanha as suas mudanças alguns segundos depois. Desligado, o link mostra a página como estava no momento em que você publicou, e você atualiza quando quiser.
* **Tirar do ar**: o link para de funcionar na hora.
Todos os links publicados ficam em **Configurações → Links publicados**.
## Texto puro para IAs e programas [#texto-puro-para-ias-e-programas]
Todo link tem duas versões sem enfeite, boas para colar numa IA ou ler num programa:
| Endereço | O que devolve |
| ---------------------------------- | ---------------------------------------------------------- |
| `https://wire.ia.br/s/codigo` | A página para pessoas |
| `https://wire.ia.br/s/codigo.md` | Só o Markdown |
| `https://wire.ia.br/s/codigo.json` | Título, texto puro, Markdown, blocos e data de atualização |
A janela de compartilhar tem botões para copiar cada versão.
## O que não dá para compartilhar [#o-que-não-dá-para-compartilhar]
* **Páginas protegidas por senha.** Tire a senha antes, se quiser mesmo publicar.
* **Conteúdo ilegal, spam ou dados pessoais de outras pessoas.** Links assim saem do ar e a conta é banida. Veja os [termos](/termos/uso-justo).
## O que fica no servidor [#o-que-fica-no-servidor]
O texto de uma página compartilhada fica guardado no servidor do Paper, sem criptografia, enquanto o link existir. É o preço de qualquer pessoa conseguir abrir. Quando você tira do ar ou o prazo vence, a cópia é apagada.
Os links não aparecem no Google nem em outros buscadores.
## Denunciar uma página [#denunciar-uma-página]
Encontrou um link do Paper com conteúdo que viola os termos? Use o link **Denunciar** no rodapé da página publicada, ou abra o [suporte](https://wire.ia.br/suporte/) e escolha o assunto **Denunciar uma nota publicada**.
# Escrever e ler
Fonte: https://wire.ia.br/documentation/guia/escrever-e-ler
> Blocos, modo edição, modo leitura, modelos e o menu de cada página.
## Blocos [#blocos]
Cada linha de uma página é um bloco. A barra `/` numa linha vazia mostra todos os tipos:
| Bloco | Para quê |
| --------------------- | -------------------------------------------------------------------------------- |
| Texto, títulos | O básico. `#`, `##` e `###` no começo da linha também viram títulos. |
| Lista, lista numerada | `-` ou `1.` no começo da linha. |
| Tarefa | `[ ]` no começo da linha. Aparece na Agenda se tiver data. |
| Citação e destaque | Para chamar atenção a um trecho. |
| Código | Texto com espaçamento fixo, com cor por linguagem. |
| Tabela | Colunas com tipo (texto, número, data, caixa de marcar, opção) e soma no rodapé. |
| Quadro | Colunas com cartões que você arrasta, como um Kanban. |
| Cronograma | Etapas com início e fim numa linha do tempo. |
| Gráfico | Barras, linhas, área ou pizza, a partir de uma tabelinha. |
| Imagem e arquivo | Arraste do computador para a página. |
Arrastar um arquivo `.md` ou `.txt` para dentro de uma página traz o texto dele como blocos. Outros arquivos viram anexos.
## Modo edição e modo leitura [#modo-edição-e-modo-leitura]
O botão **Ler** no topo da página liga o modo leitura. Nele, nenhum clique muda o texto: bom para consultar no celular, apresentar numa reunião ou revisar sem medo. Tarefas e quadros também ficam travados.
* **Ctrl Shift L** alterna entre ler e editar.
* O Paper lembra a escolha de cada página.
* Para abrir tudo em modo leitura por padrão: **Configurações → Editor → Abrir páginas em modo leitura**.
## Modelos [#modelos]
Uma página vazia mostra modelos prontos: reunião, projeto, lista de tarefas, leitura de livro, estudo e planejamento da semana. Clique em um para começar com a estrutura montada.
## Menu da página [#menu-da-página]
Os três pontos no topo da página abrem o menu:
* **Ícone**: escolha um emoji que aparece na barra lateral e acima do título.
* **Duplicar**: cria uma cópia logo abaixo.
* **Mover**: leva a página para outra pasta ou para dentro de outra página.
* **Copiar link interno**: copia o `[[link]]` para colar em outra página.
* **Compartilhar**: cria um link público. Veja [Compartilhar](/guia/compartilhar).
Ao lado da data de edição, a página mostra quantas palavras tem e quanto tempo leva para ler.
## Baixar uma página [#baixar-uma-página]
O botão de exportar no topo da página baixa só ela, em `.md`, PDF ou Word.
# Grupos e amizades
Fonte: https://wire.ia.br/documentation/guia/grupos
> Notas em equipe, criptografadas de ponta a ponta, com edição ao mesmo tempo.
O caderno pessoal e os grupos ficam separados. O que é seu continua só seu; o que é do grupo fica no espaço do grupo. Troque entre eles pelo seletor no topo da barra lateral, o mesmo dos cofres. **Novo grupo** fica no fim dessa lista.
## Amizades [#amizades]
Cada conta tem um ID de 32 caracteres, em **Configurações → Perfil**. Para adicionar alguém:
* **Pelo ID**: a pessoa te passa o ID dela e você manda um pedido.
* **Por convite**: crie um link em **Configurações → Amizades**, com prazo e número de usos. Quem abre o link vira sua amizade.
Em **Amizades** você escolhe quem pode te mandar pedidos (qualquer pessoa ou só por link) e bloqueia quem quiser.
## Grupos [#grupos]
Um grupo é um espaço de páginas compartilhado. Todo mundo do grupo vê as mesmas páginas e edita ao mesmo tempo, vendo quem está em cada página.
| Papel | O que pode |
| ------ | ---------------------------------------------------- |
| Dono | Tudo, inclusive apagar o grupo |
| Admin | Convidar, remover e mudar papéis de quem está abaixo |
| Editor | Criar e editar páginas |
| Leitor | Só ler |
Grupos precisam de internet, já que a edição é ao vivo. O caderno pessoal funciona sem.
## Criptografia de ponta a ponta [#criptografia-de-ponta-a-ponta]
O conteúdo dos grupos é cifrado no aparelho antes de sair. O servidor do Paper repassa e guarda só dados embaralhados, sem a chave para abrir. Por isso:
* Nenhum token de acesso lê grupos.
* Se todo mundo do grupo perder a chave, ninguém recupera o conteúdo, nem o Paper.
## Sem chat [#sem-chat]
O Paper não tem chat. O foco é escrever junto: para combinar algo sobre uma página, escreva nela mesma.
# Importar arquivos .md
Fonte: https://wire.ia.br/documentation/guia/importar
> Traga notas em Markdown, pastas inteiras e arquivos .zip.
O Paper lê Markdown comum. Dá para trazer uma nota solta, uma pasta cheia de notas ou um `.zip` exportado de outro app.
## Jeitos de importar [#jeitos-de-importar]
Arraste arquivos `.md` do computador para a barra lateral. Soltando em cima de uma pasta, eles entram nela. Soltando dentro de uma página aberta, o texto entra como blocos naquele ponto.
Abra uma pasta e use **Importar .md aqui**. Os arquivos escolhidos entram dentro dela.
**Configurações → Importar e exportar → Importar**. Aceita arquivos `.md`, `.txt`, pastas inteiras e `.zip`, inclusive `.zip` dentro de `.zip`. Antes de importar, o Paper mostra quantas páginas e anexos vão entrar.
## O que vem junto [#o-que-vem-junto]
* **Pastas e subpastas** viram pastas do Paper, na mesma ordem.
* **Frontmatter** (o bloco `---` no topo) vira propriedades da página.
* **Links** `[[Página]]` e links Markdown entre arquivos viram links do Paper.
* **Imagens e anexos** citados nas notas, como `![[foto.png]]` ou ``, entram junto. Arquivos que nenhuma nota cita ficam de fora.
* **Tarefas, tabelas, callouts e blocos de código** continuam iguais.
Cada anexo pode ter até 25 MB.
## Exportar [#exportar]
Em **Configurações → Importar e exportar**, a opção **Exportar o cofre inteiro** gera um `.zip` com todas as páginas em `.md`, organizadas nas pastas. É o mesmo formato que vai para o Google Drive. Para baixar uma página só, use o botão de exportar no topo dela (`.md`, PDF ou Word).
# Privacidade e segurança
Fonte: https://wire.ia.br/documentation/guia/privacidade-e-seguranca
> Onde as notas ficam, o que o servidor enxerga e como trancar uma página.
## Onde cada coisa fica [#onde-cada-coisa-fica]
| O quê | Onde fica | O servidor do Paper lê? |
| ----------------------------- | --------------------------------- | ------------------------------------ |
| Notas pessoais | No aparelho e no seu Google Drive | Não |
| Páginas protegidas por senha | Cifradas, no aparelho e no Drive | Não, nem com a senha errada |
| Grupos | Cifrados no servidor | Não, só repassa |
| Links publicados | No servidor, em texto aberto | Sim, para mostrar a quem abre o link |
| Cópias para IA (token seguro) | No servidor, em texto aberto | Sim, enquanto a cópia existir |
| Conta, amizades, sessões | No servidor | Sim |
## Páginas protegidas [#páginas-protegidas]
O cadeado no topo de uma página tranca o conteúdo com uma senha sua. A página é cifrada no aparelho com uma chave derivada da senha e um sal aleatório, então:
* Nem o Paper consegue abrir sem a senha. Guarde bem: não existe recuperação.
* Nenhum token de acesso abre páginas protegidas. A API responde `423`.
* Páginas protegidas não podem ser publicadas por link.
## Tokens de acesso [#tokens-de-acesso]
Um token só faz o que você marcou ao criar: quais cofres, ler ou editar, agenda e anexos. Você revoga em **Configurações → Desenvolvedor**, e ele para na hora. Detalhes em [Tokens](/api/tokens).
## Sessões [#sessões]
Em **Configurações → Conta e segurança** você vê os aparelhos conectados e encerra os que não reconhece.
## Mais [#mais]
* [Política de privacidade](https://wire.ia.br/privacidade/)
* [Termos de uso](https://wire.ia.br/termos/)
* [Cookies e armazenamento local](https://wire.ia.br/cookies/)
# Sincronizar com o Google Drive
Fonte: https://wire.ia.br/documentation/guia/sincronizar
> Conecte uma vez por aparelho e o Paper mantém o celular e o computador iguais.
O Paper guarda tudo primeiro no aparelho. A sincronização copia cada página para a pasta **Paper** do seu Google Drive e traz de volta o que mudou em outro aparelho.
## Conectar [#conectar]
Abra **Configurações → Sincronização** e toque em **Conectar o Google neste aparelho**.
Uma janela do Google abre. Escolha a conta e aceite. O Paper pede acesso só aos arquivos que ele mesmo cria no Drive e a uma agenda própria chamada Paper. Ele não enxerga o resto do seu Drive nem as suas outras agendas.
Pronto. A conexão fica guardada neste aparelho e não expira sozinha. Repita uma vez em cada aparelho que você usa.
## Como fica no Drive [#como-fica-no-drive]
```txt
Paper/ ← cofre principal
Comece por aqui.md
Guias/
Vindo do Obsidian.md
Anexos/
a1b2c3d4e5-foto.png
Paper · Trabalho/ ← outro cofre
...
```
O cofre principal fica na pasta **Paper**, e cada outro cofre ganha a sua, **Paper · nome do cofre**. Cada pasta do Paper vira uma pasta do Drive, e cada página vira um arquivo `.md` que qualquer editor abre.
Se a mesma página mudar em dois aparelhos antes de sincronizar, a versão do aparelho que sincronizou por último fica, e a outra vira uma cópia "(outra versão)". Nada se perde.
## Se aparecer "Falta conectar" [#se-aparecer-falta-conectar]
O Google pode cortar o acesso se você trocar a senha da conta Google, remover o Paper em [myaccount.google.com/permissions](https://myaccount.google.com/permissions) ou ficar muitos meses sem usar. Nesses casos, toque em **Conectar** de novo. Nada se perde: o que você escreveu enquanto isso continua no aparelho e sobe assim que a conexão voltar.
Sem internet, o Paper continua salvando no aparelho e tenta sincronizar de novo sozinho quando a conexão volta.
## Desconectar [#desconectar]
Em **Configurações → Integrações**, **Desconectar o Google** apaga a conexão deste aparelho e avisa o Google para cancelar o acesso. Os arquivos que já estão no seu Drive continuam lá.
## Quem guarda a conexão [#quem-guarda-a-conexão]
A chave que mantém a conexão fica no seu aparelho, lacrada: só o servidor do Paper consegue abrir, e só no momento de renovar o acesso. O servidor não guarda essa chave, a não ser que você ligue o [modo desenvolvedor](/api/modo-desenvolvedor) e autorize a API a usar o seu Drive.
# Vindo de outro app
Fonte: https://wire.ia.br/documentation/guia/vindo-de-outros-apps
> Para quem usava Obsidian ou Notion. Como trazer as notas e onde cada coisa ficou.
Se você vem de um cofre de Markdown, quase tudo funciona igual.
### Trazer o cofre [#trazer-o-cofre]
1. **Configurações → Importar e exportar → Importar**.
2. Escolha a pasta do cofre ou um `.zip` dela. Pastas, subpastas, links, frontmatter, callouts, tarefas, tabelas e imagens vêm junto.
3. Se preferir manter separado, crie antes um cofre novo pelo topo da barra lateral e importe lá.
### Onde cada coisa ficou [#onde-cada-coisa-ficou]
| Você usava | No Paper |
| ------------------------------------------------- | ------------------------------------------------------- |
| Cofre | Cofre, trocado pelo topo da barra lateral |
| `[[Link]]`, `[[Link\|apelido]]`, `[[Link#seção]]` | Iguais, e acompanham quando você renomeia |
| Backlinks | "Mencionada em", no fim da página, com menções sem link |
| Graph view | Mapa das ideias, com o modo "em volta de uma página" |
| Daily notes | Botão Hoje, uma página por dia dentro de Diário |
| Command palette | Ctrl K, com filtros como `#tag` e tarefas abertas |
| Callouts `> [!nota]` | Bloco Destaque, e o `.md` continua com `> [!nota]` |
| Plugin de Kanban | Bloco Quadro, nativo |
| Sync | Google Drive de graça, ou grupos com edição ao vivo |
### O que ainda não tem [#o-que-ainda-não-tem]
* Canvas e consultas que juntam várias páginas.
* Plugins de terceiros. Para automações, use os [tokens de acesso](/api/tokens).
Se você vem de um workspace com páginas e bancos de dados, este é o caminho mais curto.
### Trazer as páginas [#trazer-as-páginas]
1. No app de onde você vem, exporte o workspace como **Markdown & CSV**.
2. No Paper: **Configurações → Importar e exportar → Importar**, e escolha o `.zip`. Pode ser `.zip` dentro de `.zip`.
3. Os códigos de 32 letras no fim dos nomes somem sozinhos, e os links entre páginas viram `[[links]]`.
### Onde cada coisa ficou [#onde-cada-coisa-ficou-1]
| Você usava | No Paper |
| -------------------- | ------------------------------------------------------------------ |
| Páginas e subpáginas | Iguais, e agora também pastas de verdade |
| `/` para blocos | Igual: `/` abre a lista de blocos |
| Tabela simples | Bloco Tabela, com tipos de coluna e soma |
| Board | Bloco Quadro |
| Timeline | Bloco Cronograma |
| `@data` | `@data` vira data na Agenda |
| Teamspace | Grupos, criptografados de ponta a ponta, com edição ao mesmo tempo |
| Share to web | Botão Compartilhar, com versão em texto puro para IAs |
| Assistente de IA | Tokens de acesso: sua IA lê e escreve só onde você deixar |
### A diferença principal [#a-diferença-principal]
Suas notas pessoais não ficam num servidor do Paper. Ficam no seu aparelho e, se você conectar, no seu Google Drive, em arquivos `.md` que qualquer editor abre.
### O que ainda não tem [#o-que-ainda-não-tem-1]
* Bancos de dados que juntam várias páginas.
* Arquivos `.csv` exportados ficam de fora por enquanto.
# Documentação do Paper
Fonte: https://wire.ia.br/documentation/
> Como usar o caderno, conectar outros aparelhos e dar acesso a programas e agentes de IA com tokens.
O Paper é um caderno de notas. Você escreve, organiza em cofres e pastas, liga uma página na outra e leva tudo para outros aparelhos pelo seu Google Drive. As notas pessoais ficam no seu aparelho e no seu Drive, em arquivos `.md` que qualquer editor abre.
Esta documentação tem duas partes. O **guia** é para quem usa o app. A **API pessoal** é para quem quer que um programa ou uma IA leia e escreva no caderno, só onde a pessoa permitir.
## Para agentes de IA [#para-agentes-de-ia]
Se você é um agente de IA, comece pelo mapa em JSON. Ele lista cada página desta documentação, o endereço da versão em texto puro e as regras de uso:
```txt
https://wire.ia.br/documentation/agents/raw.json
```
Toda página daqui tem o botão **Ver em texto puro**, que abre o Markdown limpo da página. A documentação inteira em um arquivo só fica em [`/documentation/llms-full.txt`](https://wire.ia.br/documentation/llms-full.txt), e o índice em [`/documentation/llms.txt`](https://wire.ia.br/documentation/llms.txt).
## Regras em uma frase [#regras-em-uma-frase]
O Paper é um lugar seguro para pensar e anotar. Use como caderno, não como banco de dados nem como hospedagem de arquivos. Quem viola os [termos da API](/termos/termos-da-api) perde a conta de forma permanente, e só uma [apelação](/termos/banimento-e-apelacao) aceita reverte.
# Banimento e apelação
Fonte: https://wire.ia.br/documentation/termos/banimento-e-apelacao
> Quando uma conta é banida, o que acontece com ela e como pedir revisão.
## Quando banimos [#quando-banimos]
Banimos contas que violam os [termos de uso](https://wire.ia.br/termos/) ou os [termos da API](/termos/termos-da-api). Os casos mais comuns:
* Usar o Paper como banco de dados ou hospedagem de arquivos.
* Contornar limites da API com vários tokens ou várias contas.
* Spam, golpes ou conteúdo ilegal em links publicados.
* Tentar invadir, derrubar ou explorar falhas do serviço.
## O que acontece [#o-que-acontece]
O banimento é permanente e corta o acesso na hora:
* A conta não entra mais. Quem tenta entrar vai para a página de apelação.
* Todas as sessões são encerradas.
* Todos os tokens são revogados e as cópias para IA são apagadas.
* Todos os links publicados saem do ar.
* A conexão com o Google guardada no servidor é apagada.
* A conta perde o acesso aos grupos. O conteúdo deles continua com os outros membros.
## O que continua seu [#o-que-continua-seu]
Suas notas pessoais ficam no seu navegador e no seu Google Drive, em arquivos `.md`. O banimento não apaga nada disso, e você pode abrir esses arquivos em qualquer editor.
## Apelação [#apelação]
O banimento não volta sozinho. A única forma de reverter é uma apelação aceita.
Abra [wire.ia.br/apelacao](https://wire.ia.br/apelacao/).
Deixe um contato para a resposta, o ID da conta (32 caracteres, em Configurações → Perfil, se você souber) e explique o que aconteceu.
Uma pessoa lê cada apelação e responde pelo contato que você deixou, em até 15 dias.
Uma apelação por caso. Mandar várias não acelera a resposta.
## Denunciar [#denunciar]
Viu um link do Paper com conteúdo que viola os termos? Use o link **Denunciar** no rodapé da página publicada, ou o [suporte](https://wire.ia.br/suporte/) com o assunto **Denunciar uma nota publicada**.
# Termos de uso da API
Fonte: https://wire.ia.br/documentation/termos/termos-da-api
> As regras que você aceita ao ligar o modo desenvolvedor. Versão de 2 de outubro de 2026.
Estes termos valem para os tokens de acesso e para a API pessoal do Paper. Eles completam os [termos de uso](https://wire.ia.br/termos/) e a [política de privacidade](https://wire.ia.br/privacidade/) do app. Você aceita esta versão ao ligar o modo desenvolvedor.
## 1. Para que a API existe [#1-para-que-a-api-existe]
A API deixa programas e agentes de IA ajudarem você no seu próprio caderno: ler, organizar, escrever, criar tarefas e eventos. Ela atende uma pessoa por vez, a dona do token.
## 2. Sua responsabilidade [#2-sua-responsabilidade]
* O token é seu. Tudo o que for feito com ele conta como feito pela sua conta, inclusive por uma IA ou um programa de outra pessoa a quem você deu o token.
* Guarde o token com cuidado e revogue na hora se suspeitar de vazamento.
* Confira as permissões antes de entregar um token. Dê só o necessário.
## 3. Permitido [#3-permitido]
* Ler, criar e editar notas onde o token tem permissão.
* Organizar, resumir, revisar e transformar anotações em tarefas, datas e eventos.
* Enviar arquivos que fazem parte das suas notas, dentro dos [limites](/api/limites).
* Automatizar rotinas suas, como a página do dia ou um resumo semanal.
## 4. Proibido [#4-proibido]
* Usar o Paper como banco de dados, fila, cache, log ou armazenamento de outro sistema.
* Hospedar imagens ou arquivos para outros sites, apps ou pessoas baixarem, inclusive por links publicados.
* Contornar limites com vários tokens, várias contas ou pedidos em rajada.
* Consultar sem parar para detectar mudanças (mais de uma checagem por minuto).
* Publicar ou enviar spam, conteúdo ilegal, conteúdo de abuso ou dados pessoais de outras pessoas sem autorização.
* Tentar abrir páginas protegidas, ler dados de outras contas, testar falhas de segurança sem autorização ou sobrecarregar o serviço.
* Revender o acesso ou oferecer a API do Paper como serviço para terceiros.
## 5. Consequência [#5-consequência]
Violar a seção 4 leva ao **banimento permanente** da conta: tokens revogados, links publicados fora do ar e acesso encerrado. O banimento não volta sozinho. Só uma [apelação](/termos/banimento-e-apelacao) aceita reverte.
Suas notas pessoais continuam no seu aparelho e no seu Google Drive mesmo depois de um banimento: o Paper não apaga arquivos do seu Drive.
## 6. Disponibilidade [#6-disponibilidade]
A API pode mudar, ter manutenção ou sair do ar. Mudanças que quebram programas serão avisadas em [Novidades](/ajuda/novidades) com antecedência, quando possível. Os limites podem mudar para proteger o serviço.
## 7. Mudanças nestes termos [#7-mudanças-nestes-termos]
Quando estes termos mudarem, o app pede um novo aceite antes de liberar os tokens de novo.
## 8. Contato [#8-contato]
O Paper e a API são oferecidos por Israel de Jesus Silva, pessoa física, no Brasil.
Dúvidas sobre estes termos: [contato.brennoleon@gmail.com](mailto:contato.brennoleon@gmail.com) ou o [suporte](https://wire.ia.br/suporte/), assunto **API e tokens de acesso**.
# Uso justo
Fonte: https://wire.ia.br/documentation/termos/uso-justo
> O Paper é um caderno. O que isso quer dizer na prática.
O Paper é um lugar seguro para pensar, anotar e organizar a vida. Ele foi feito para ser usado como caderno, por pessoas, com a ajuda de programas e IAs quando elas quiserem.
## Uso de caderno [#uso-de-caderno]
* Notas, listas, diários, estudos, projetos, atas, rascunhos.
* Imagens e arquivos que fazem parte dessas notas.
* Automações que ajudam a pessoa: criar a página do dia, juntar tarefas, resumir a semana.
## Uso que não cabe [#uso-que-não-cabe]
* **Banco de dados.** Gravar milhares de registros de um sistema, dados de sensores, logs ou respostas de outros serviços.
* **Hospedagem de arquivos.** Subir imagens para usar em outros sites, apps ou lojas, ou distribuir arquivos por links publicados.
* **Fila ou integração entre sistemas.** Usar páginas como mensagens entre programas.
* **Contas em série.** Criar várias contas ou tokens para somar limites.
Esses usos pesam no serviço de todo mundo e levam a banimento permanente. Veja [Banimento e apelação](/termos/banimento-e-apelacao).
## Imagens na nuvem [#imagens-na-nuvem]
Hoje, as imagens das suas notas ficam no seu aparelho e no seu Google Drive. Hospedagem de imagens na nuvem do Paper, para o plano pago, é um recurso futuro e ainda não existe.
## Na dúvida [#na-dúvida]
Se você não sabe se um uso cabe, pergunte antes pelo [suporte](https://wire.ia.br/suporte/).