# What's new
Source: https://wire.ia.br/documentation/en/ajuda/novidades
> What changed in each version. Changes that affect the API show up here first.
## 0.7 · October 2026 [#07--october-2026]
### Languages [#languages]
* **Paper in three languages.** Português (Brasil), English and Español, in the landing page, the app, the legal pages, server messages and this documentation.
* **Language detection.** The app suggests the language of your browser and remembers your choice, per account and per device. Change it in **Settings → Appearance → Language**.
* **Regional formats.** Dates, numbers, first day of the week and 12 or 24-hour clock follow your region. The app can detect your country from your connection, without storing it on the server.
* **Other languages by browser translation.** For any other language, your browser's automatic translator works on the interface. Your notes, page titles and the editor are marked so they are never translated or changed.
* **Dates in notes.** Words like "tomorrow", "next week" and weekdays are understood in the three languages.
### API [#api]
* Error messages follow the `Accept-Language` header (`pt-BR`, `en` or `es`). Field names don't change.
* New endpoint `GET /api/locale`, public, which returns the detected language and the regional formats.
## 0.6 · October 2026 [#06--october-2026]
### In the app [#in-the-app]
* **Folders.** Create folders and folders inside folders. In Google Drive, they become real folders.
* **Import `.md`.** Drag loose notes, folders or `.zip` files to the sidebar, to a folder or into a page. Images they cite come along.
* **Read mode.** The Read button at the top of the page, or Ctrl Shift L. Paper remembers the choice for each page.
* **Share by link.** With expiry, live mode and plain-text versions (`.md` and `.json`) for AIs.
* **Page menu.** Icon, duplicate, move and copy internal link.
* **Templates** for empty pages: meeting, project, tasks, reading, study and week.
* **Guides** in place of sample pages in new accounts.
* **Stable sync.** The Google connection is kept on the device and renews itself. You only need to connect once per device.
### API [#api-1]
* First version of the [personal API](/en/api/visao-geral): vaults, pages, search, attachments and calendar.
* [Developer mode](/en/api/modo-desenvolvedor) and [access tokens](/en/api/tokens), with the secure token for AI.
* [API terms](/en/termos/termos-da-api), version of October 2, 2026.
* Documentation map for agents at [`/documentation/agents/raw.json`](https://wire.ia.br/documentation/agents/raw.json).
### Moderation [#moderation]
* [Support](https://wire.ia.br/en/support/) and [appeal](https://wire.ia.br/en/appeal/) pages.
## 0.5 · September 2026 [#05--september-2026]
* Groups with live editing and end-to-end encryption, friendships by ID or invitation.
* Password-protected pages, attachments, tables, boards, timelines and charts.
* Separate vaults and a simpler map of ideas.
---
# Support
Source: https://wire.ia.br/documentation/en/ajuda/suporte
> How to reach Paper and what to send so the answer comes faster.
The support form is at [wire.ia.br/en/support](https://wire.ia.br/en/support/). You don't need to be signed in. If you prefer email, write to [contato.brennoleon@gmail.com](mailto:contato.brennoleon@gmail.com).
Replies come in English, Spanish or Portuguese.
## Subjects [#subjects]
| Subject | What for |
| -------------------------------- | --------------------------------------------------- |
| Question about how to use it | Something this documentation didn't answer |
| Something isn't working | Errors, stuck sync, a button that doesn't respond |
| My account and my data (privacy) | Ask for a copy, correction or deletion of your data |
| API and access tokens | Questions about the API, limits, use cases |
| Report a published note | Public link with content that violates the terms |
| Other subject | Suggestions and the rest |
## So the answer comes faster [#so-the-answer-comes-faster]
* Say the device and the browser (for example, "Android, Chrome").
* For problems, tell the step by step up to the error and copy the message that showed up.
* For the API, send the response code and the error message. **Never send the token.** The 8 characters in the middle (`paper_k3m9x2ab_…`) are enough to find the token.
## Banned account [#banned-account]
Use the [appeal](https://wire.ia.br/en/appeal/). See [Bans and appeals](/en/termos/banimento-e-apelacao).
## Before writing [#before-writing]
* Did sync ask you to connect? See [Sync with Google Drive](/en/guia/sincronizar).
* Did the API answer with an error? See [Errors](/en/api/erros).
---
# Calendar
Source: https://wire.ia.br/documentation/en/api/agenda
> Read, create and delete events in the "Paper" Google Calendar.
The API only touches the calendar called **Paper**, which the app itself creates in the person's Google Calendar. Their other calendars stay out of reach.
Before using it:
1. The person connects Google Calendar in **Settings → Integrations**.
2. In **Settings → Developer**, they tap **Allow the "Paper" calendar for the API**.
3. The token needs the calendar permission. Secure tokens don't access the calendar.
Without the first two steps, the API answers `409`.
## List events [#list-events]
```http
GET /calendar/events?from=2026-10-01&to=2026-10-31
```
`from` and `to` accept a date or a date and time in ISO 8601. Without `from`, it starts now. Without `to`, it goes 30 days past `from`. Returns up to 250 events, in order of start.
```json
[
{
"id": "k9d8f7g6h5j4",
"titulo": "Dentist",
"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" }
}
]
```
All-day events come with `{ "date": "2026-10-06" }` in `inicio` and `fim`.
## Create an event [#create-an-event]
```http
POST /calendar/events
Content-Type: application/json
```
```json
{
"title": "Deliver report",
"date": "2026-10-08",
"time": "09:30",
"durationMinutes": 45,
"description": "Final version, with the charts.",
"timeZone": "America/New_York"
}
```
| Field | Required | Rules |
| ----------------- | -------- | -------------------------------------------------------- |
| `title` | No | Up to 300 characters. Empty becomes "Event". |
| `date` | Yes | `YYYY-MM-DD`. |
| `time` | No | `HH:MM`, 24 hours. Without a time, the event is all-day. |
| `durationMinutes` | No | From 5 to 1440. Default: 60. |
| `description` | No | Up to 4000 characters. |
| `timeZone` | No | IANA time zone. Default: `America/Sao_Paulo`. |
Response: `{ "id": "…" }`. Needs the **Read and create events** permission.
## Delete an event [#delete-an-event]
```http
DELETE /calendar/events/{id}
```
Only deletes events in the "Paper" calendar. Needs the **Read and create events** permission.
## Common sense [#common-sense]
Create events the person asked for or that come from their notes. Don't fill the calendar with repeated reminders or use the calendar as a system's task queue.
---
# AI agents
Source: https://wire.ia.br/documentation/en/api/agentes-de-ia
> Rules and a script for an AI to use someone's notebook with care.
This page speaks directly to AI agents. If you're a person setting up an agent, send it the text of the **Copy instructions for the AI** button and the link to the map:
```txt
https://wire.ia.br/documentation/agents/raw.json
```
## Script [#script]
**Confirm who you serve.** Call `GET /api/v1/me` with `Authorization` and `X-Paper-Account`. If the account doesn't match, stop and tell the person.
**See what you can do.** The `/me` response brings the token type and the permissions. `GET /vaults` shows the vaults you reach. If the vault id starts with `copia-`, you work on a copy and the person reviews everything afterward.
**Read before writing.** List the pages, read the ones that matter for the request. Keep the list in memory during the task instead of asking again at every step.
**Change the minimum.** Prefer `append` over rewriting the whole page. When rewriting, preserve what the person wrote and the format of the blocks (see [Page format](/en/api/formato-das-paginas)).
**Say what you did.** At the end, tell the person which pages you created, changed or sent to the trash, with the titles.
## Do [#do]
* Respect the permissions. `403` means no: don't try another route.
* Treat protected pages (`423`) as closed. Don't ask the person for the password and don't try to guess the content.
* On `429`, stop, wait and come back at a lower pace. See [Limits](/en/api/limites).
* Write in clear language, the way the person writes. Use Paper's blocks when they help: tasks with `@date`, tables, boards.
* Create a folder for what you produce, if the person didn't say where to put it.
* Send `Accept-Language` with the person's language, so error messages come in a language they read.
## Don't [#dont]
* Don't use the notebook as your own long-term memory, a database, a task queue or an execution log.
* Don't upload files to be hosted somewhere else.
* Don't poll in a loop to see if something changed. One check per minute, at most.
* Don't copy the notebook's content out of the conversation with the person unless they ask.
* Don't show the token in answers, logs or files.
* Don't delete in bulk. For more than 10 pages at once, ask for confirmation.
Breaking these rules leads to the permanent ban of the account of the person who trusted the token to you. The full terms are in [API terms](/en/termos/termos-da-api).
## Sample instructions [#sample-instructions]
```txt
You have access to my Paper notebook through the personal API.
Token (send in the header Authorization: Bearer): paper_…
My account: 3f2a… (also send in the header X-Paper-Account)
API base: https://wire.ia.br/api/v1
Read the documentation map first: https://wire.ia.br/documentation/agents/raw.json
Respect the limits and the API terms of use described there. Use the notebook as a notebook, not as a database.
```
## Tools for the agent [#tools-for-the-agent]
If your agent accepts tools you define, these five cover almost everything:
| Tool | Request |
| ------------------------------------------ | ------------------------------------------------ |
| `list_pages(vault)` | `GET /vaults/{vault}/pages` |
| `read_page(vault, id)` | `GET /vaults/{vault}/pages/{id}?format=md` |
| `search(vault, text)` | `GET /vaults/{vault}/search?q=` |
| `create_page(vault, title, text, folder?)` | `POST /vaults/{vault}/pages` |
| `append(vault, id, text)` | `PATCH /vaults/{vault}/pages/{id}` with `append` |
Ready-made examples in [Examples](/en/api/exemplos).
---
# Attachments
Source: https://wire.ia.br/documentation/en/api/anexos
> Upload images and files that are part of the notes.
```http
POST /vaults/{vault}/files?name={file.ext}
Content-Type: image/png
(body: the file's bytes)
```
The file goes to the vault's **Attachments** folder (`Anexos`), in the person's Google Drive. The response brings the Markdown ready to put in a page:
```json
{ "ref": "a3f9c21b7e-chart.png", "markdown": "" }
```
Images come back as ``. Other files come back as a link `[📎 name](Anexos/ref)`.
## Example [#example]
```bash
curl -X POST "https://wire.ia.br/api/v1/vaults/principal/files?name=chart.png" \
-H "Authorization: Bearer $PAPER_TOKEN" \
-H "X-Paper-Account: $PAPER_ACCOUNT" \
-H "Content-Type: image/png" \
--data-binary @chart.png
```
Then append the Markdown to a page:
```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": ""}'
```
## Rules [#rules]
| Rule | Value |
| ------------- | ------------------------------------------------------------------ |
| Permission | Regular token with "Send files" and **Read and edit** on the vault |
| Maximum size | 10 MB per file |
| Quantity | 30 uploads per day, per token |
| Copies for AI | Don't receive files |
## What it's for, and what it isn't [#what-its-for-and-what-it-isnt]
Attachments exist for the person's notes: the photo of the meeting whiteboard, the PDF a page comments on, the chart a script generated for a report.
Don't use Paper to host images or files that other sites, apps or people will download. That includes using published links as a CDN. Hosting abuse leads to a permanent ban. See [Fair use](/en/termos/uso-justo).
Cloud image hosting for the paid plan is a future feature and doesn't exist yet.
---
# Authentication
Source: https://wire.ia.br/documentation/en/api/autenticacao
> The token header, account confirmation with the ID and the language of the answers.
Every request carries the token in the `Authorization` header:
```http
GET /api/v1/vaults HTTP/1.1
Host: wire.ia.br
Authorization: Bearer paper_k3m9x2ab_Q7wLc2…
X-Paper-Account: 3f2a9c…(account ID, 32 characters)
Accept-Language: en
```
## Account confirmation [#account-confirmation]
The `X-Paper-Account` header is optional and recommended. It carries the ID of the account that owns the token, shown in **Settings → Developer** and in **Settings → Profile**.
If the ID doesn't match the token's owner, the request fails with `403`, without touching anything. This keeps an agent from using, by mistake, someone else's token left in a history, an old file or the wrong conversation.
AI agents should always send this header.
## Language of the answers [#language-of-the-answers]
Error messages come in the language of `Accept-Language`: `pt-BR` (default), `en` or `es`. JSON field names don't change.
## What's checked on every request [#whats-checked-on-every-request]
1. The token format.
2. Whether the token exists, wasn't revoked and hasn't expired (`401` if not).
3. Whether the account exists, isn't banned, has developer mode on and has accepted the current API terms (`403` if not).
4. Whether `X-Paper-Account` matches the account (`403` if not).
5. The per-minute and per-day limits (`429` if exceeded). See [Limits](/en/api/limites).
6. Whether the token has permission for the request's vault, calendar or attachments (`403` if missing).
## Good practices [#good-practices]
* Always use `https://`. A request to `http://` is redirected, but the token has already traveled unprotected.
* Don't send the token as a URL parameter. It shows up in logs and histories.
* Keep the token out of the code: environment variable, secrets manager or password vault.
---
# Search
Source: https://wire.ia.br/documentation/en/api/busca
> Find pages by title and text inside a vault.
```http
GET /vaults/{vault}/search?q={text}
```
Searches the title and text of the vault's pages. Returns up to 50 results. The search text can be up to 100 characters.
```bash
curl "https://wire.ia.br/api/v1/vaults/principal/search?q=budget" \
-H "Authorization: Bearer $PAPER_TOKEN" \
-H "X-Paper-Account: $PAPER_ACCOUNT"
```
## Response with a regular token [#response-with-a-regular-token]
The search runs in the person's Google Drive and returns the pages it found:
```json
[
{ "id": "pa1k2m3n4o5p", "title": "Monday meeting", "kind": "pagina", "updatedAt": "2026-10-01T14:03:11.000Z" }
]
```
To read the text, request the page with `GET /vaults/{vault}/pages/{id}`.
## Response with a secure token [#response-with-a-secure-token]
In the copy for AI, each result already comes with a snippet around what was found:
```json
[
{ "id": "pa1k2m3n4o5p", "title": "Monday meeting", "trecho": "…review the budget before the meeting with…" }
]
```
## Tips [#tips]
* Encode the text in the URL (`encodeURIComponent` in JavaScript, `urllib.parse.quote` in Python).
* To scan the whole vault, list the pages once and keep the result. Don't run one search per page.
* Protected pages never show their content. With the "Show only the title" permission, they may appear in the results by title.
---
# Vaults and pages
Source: https://wire.ia.br/documentation/en/api/cofres-e-paginas
> List vaults, list and read pages, create, edit and send to the trash.
All paths start at `https://wire.ia.br/api/v1`. The examples use `$PAPER_TOKEN` and `$PAPER_ACCOUNT` as environment variables.
## List vaults [#list-vaults]
```http
GET /vaults
```
Returns only the vaults the token reaches. With a regular token, only vaults synced with Google Drive show up. With a secure token, only its own copy shows up.
```json
[
{ "id": "principal", "nome": "My notebook", "acesso": "editar", "copia": false },
{ "id": "cmg2k1x9a4tz", "nome": "Work", "acesso": "ler", "copia": false }
]
```
The main vault always has the id `principal`. Copies for AI have ids in the format `copia-` followed by 16 characters.
## List pages [#list-pages]
```http
GET /vaults/{vault}/pages
GET /vaults/{vault}/pages?parent={id}
GET /vaults/{vault}/pages?parent=
```
Without `parent`, it returns all pages and folders in the vault. With `parent={id}`, only those inside that page or folder. With an empty `parent=`, only those at the root.
```json
[
{ "id": "pa1k2m3n4o5p", "title": "Monday meeting", "parentId": null, "kind": "pagina", "updatedAt": "2026-10-01T14:03:11.000Z" },
{ "id": "pb7q8r9s0t1u", "title": "Projects", "parentId": null, "kind": "pasta", "updatedAt": "2026-09-28T10:00:00.000Z" }
]
```
| Field | What it is |
| ----------- | ----------------------------------------------------------------------------------------- |
| `id` | Page id. The same in the app, in Drive and in the API. |
| `title` | Title. |
| `parentId` | Page or folder it sits in. `null` at the root. |
| `kind` | `pagina` (has text) or `pasta` (folder, only groups). |
| `updatedAt` | Last change, in ISO 8601. |
| `locked` | `true` on protected pages. They only appear in the list if the token may see their title. |
## Read a page [#read-a-page]
```http
GET /vaults/{vault}/pages/{id}
GET /vaults/{vault}/pages/{id}?format=md
```
```json
{
"id": "pa1k2m3n4o5p",
"title": "Monday meeting",
"parentId": null,
"kind": "pagina",
"updatedAt": "2026-10-01T14:03:11.000Z",
"markdown": "## Agenda\n\n- [ ] Review budget @2026-10-06 10:00\n- [x] Send minutes",
"props": { "tags": "work" }
}
```
With `?format=md`, the response is just the Markdown text (`text/markdown`), starting with the title. Good for pasting straight into an AI.
`props` holds the page's frontmatter properties. The Markdown format is in [Page format](/en/api/formato-das-paginas).
A page protected by a password always answers `423`.
## Create a page or folder [#create-a-page-or-folder]
```http
POST /vaults/{vault}/pages
Content-Type: application/json
```
```json
{
"title": "Weekend ideas",
"markdown": "- Hike on Saturday\n- [ ] Buy bread",
"parentId": "pb7q8r9s0t1u",
"kind": "pagina"
}
```
| Field | Required | Rules |
| ---------- | -------- | ----------------------------------------------- |
| `title` | No | Up to 200 characters. Empty becomes "Untitled". |
| `markdown` | No | Up to 1 MB. Ignored for folders. |
| `parentId` | No | Id of a page or folder in the same vault. |
| `kind` | No | `pagina` (default) or `pasta`. |
Response:
```json
{ "id": "pc2v3w4x5y6z", "title": "Weekend ideas", "kind": "pagina" }
```
Needs the **Read and edit** permission on the vault. The page shows up in the person's app on the next sync.
## Edit a page [#edit-a-page]
```http
PATCH /vaults/{vault}/pages/{id}
Content-Type: application/json
```
Send one or more of these fields:
| Field | What it does |
| ---------- | ----------------------------------------- |
| `title` | Changes the title. |
| `markdown` | Replaces the whole text. |
| `append` | Adds text at the end, after a blank line. |
```json
{ "append": "## Update\n\nThe budget was approved." }
```
Prefer `append` whenever you can. It doesn't erase anything the person wrote while your program was working.
Folders have no text: a `PATCH` on a folder with `markdown` or `append` answers `400`.
## Send to the trash [#send-to-the-trash]
```http
DELETE /vaults/{vault}/pages/{id}
```
```json
{ "ok": true, "lixeira": true }
```
The page goes to the trash of the person's Google Drive, and can be recovered from there. In copies for AI, the page is marked as deleted until the person reviews it.
## When the app sees the changes [#when-the-app-sees-the-changes]
With a regular token, the change goes straight to Google Drive. The person's app picks it up on the next sync, which happens when opening the app, when returning to the tab and from time to time. If the person touched the same page on their device at the same time, nothing is lost: one of the versions becomes a copy "(other version)".
---
# Copies for AI
Source: https://wire.ia.br/documentation/en/api/copias-para-ia
> How the secure token works, the isolated copy of a vault and the review of changes.
The secure token exists so you can hand a vault to an AI without risking the original. The AI works on a copy; you decide what comes back.
## How it works [#how-it-works]
**You create the secure token** in Settings → Developer and pick a vault. The app sends a copy of the text of that vault's pages to the server. Password-protected pages stay out.
**The AI uses the API as usual.** `GET /vaults` shows a single vault, with an id of `copia-` and 16 characters. It lists, reads, searches, creates, edits and deletes pages in that copy.
**You review.** In **Copies for AI**, the app shows how many changes are waiting. **Review changes** lists each new, edited or deleted page, with the text the AI left.
**You choose what to bring.** With the original vault open in the app, check the changes you want and tap **Bring into the vault**. They enter your device and go up to Drive on the next sync. Ctrl Z undoes it. **Discard selected** removes the changes from the list without touching your vault.
## For whoever programs the AI [#for-whoever-programs-the-ai]
Nothing changes in how you call the API. Use the copy's id where the vault id would go:
```bash
VAULT=$(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/$VAULT/pages" \
-H "Authorization: Bearer $PAPER_TOKEN"
```
Differences from the regular token:
* Search returns a snippet of text with each result.
* It doesn't upload files or touch the calendar (`403` or `400`).
* The copy takes up to 6000 pages. The original vault must have up to 20 MB of text to be copied.
* Changes the person makes in the original vault after the copy don't show up for the AI. To give it the new version, the person creates another secure token.
## What gets stored [#what-gets-stored]
The copy sits on the Paper server, in plain text, for as long as the token exists. It's deleted when the person revokes the token or turns developer mode off. Reviewing doesn't delete the copy: the AI can keep working on it. This is in the [privacy policy](https://wire.ia.br/en/privacy/).
## Tell this to the AI [#tell-this-to-the-ai]
If the AI knows it's working on a copy, it feels freer to reorganize and you keep the final word. The **Copy instructions for the AI** button, which appears when you create the token, already builds a text with the token, the account ID, the API base and the link to the [documentation map](https://wire.ia.br/documentation/agents/raw.json).
---
# Errors
Source: https://wire.ia.br/documentation/en/api/erros
> The response codes and what to do with each.
Every error comes back as JSON, with a message you can show to the person. The message is in the language of the `Accept-Language` header (`pt-BR`, `en` or `es`; Portuguese when absent):
```json
{ "error": "This token can only read this vault." }
```
| Code | When it happens | What to do |
| ----- | ------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------- |
| `400` | A field is missing or the format is wrong | Fix the request. The message says what. |
| `401` | Token missing, malformed, invalid, revoked or expired | Ask the person for a new token. Don't retry with the same one. |
| `403` | No permission for the vault, calendar or attachments; account differs from the one in `X-Paper-Account`; developer mode off; banned account | Don't insist. Tell the person what's missing. |
| `404` | Vault or page not found | Check the ids with `GET /vaults` and `GET /vaults/{vault}/pages`. Vaults must be synced with Google Drive. |
| `409` | Google or the calendar wasn't allowed for the API, or the person revoked access in Google | The person needs to open the app and allow it again in Settings → Developer. |
| `413` | File or text too large | Split or shrink it. See [Limits](/en/api/limites). |
| `423` | Page protected by a password | Leave the page alone. No token opens it. |
| `429` | Request or upload limit | Wait and try again, with growing intervals. |
| `500` | An error on our side | Try again in a few minutes. If it repeats, tell [support](https://wire.ia.br/en/support/). |
| `502` | Google Drive or Google Calendar failed | Try again later. |
| `503` | Service under maintenance | Try again later. |
## Retrying [#retrying]
Retrying only makes sense on `429`, `500`, `502` and `503`. Use growing intervals and a cap on attempts. The other codes don't change by themselves.
---
# Examples
Source: https://wire.ia.br/documentation/en/api/exemplos
> Ready-made code in curl, JavaScript and Python, from the first request to a complete automation.
All the examples read the token and the account ID from environment variables:
```bash
export PAPER_TOKEN="paper_…"
export PAPER_ACCOUNT="3f2a…"
```
## A minimal client [#a-minimal-client]
```js
// Node 18+ or browser. No dependencies.
const BASE = 'https://wire.ia.br/api/v1';
async function paper(path, { method = 'GET', body, retries = 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_ACCOUNT,
'Accept-Language': 'en',
...(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 worthIt = [429, 500, 502, 503].includes(res.status) && i < retries;
if (!worthIt) throw new Error(`${res.status}: ${error}`);
await new Promise((r) => setTimeout(r, 2000 * 2 ** i));
}
}
const me = await paper('/me');
console.log(`Connected as ${me.conta.nome}, ${me.token.tipo} token`);
```
```python
# Python 3.9+. Needs: pip install requests
import os, time, requests
BASE = "https://wire.ia.br/api/v1"
SESSION = requests.Session()
SESSION.headers.update({
"Authorization": f"Bearer {os.environ['PAPER_TOKEN']}",
"X-Paper-Account": os.environ["PAPER_ACCOUNT"],
"Accept-Language": "en",
})
def paper(path, method="GET", json=None, retries=4):
for i in range(retries + 1):
res = SESSION.request(method, BASE + path, 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 == retries:
raise RuntimeError(f"{res.status_code}: {res.json().get('error')}")
time.sleep(2 * 2 ** i)
me = paper("/me")
print(f"Connected as {me['conta']['nome']}, {me['token']['tipo']} token")
```
```bash
paper() {
curl -sS "https://wire.ia.br/api/v1$1" \
-H "Authorization: Bearer $PAPER_TOKEN" \
-H "X-Paper-Account: $PAPER_ACCOUNT" \
-H "Accept-Language: en" \
-H "Content-Type: application/json" "${@:2}"
}
paper /me
paper /vaults
```
## Create the day's page [#create-the-days-page]
Creates a page with today's date in a "Script diary" folder, if it doesn't exist yet.
```js
const today = new Date().toISOString().slice(0, 10);
const pages = await paper('/vaults/principal/pages');
let folder = pages.find((p) => p.kind === 'pasta' && p.title === 'Script diary');
if (!folder) {
folder = await paper('/vaults/principal/pages', {
method: 'POST',
body: { title: 'Script diary', kind: 'pasta' },
});
}
if (!pages.some((p) => p.parentId === folder.id && p.title === today)) {
await paper('/vaults/principal/pages', {
method: 'POST',
body: {
title: today,
parentId: folder.id,
markdown: `## For today\n\n- [ ] \n\n## Notes\n`,
},
});
}
```
```python
from datetime import date
today = date.today().isoformat()
pages = paper("/vaults/principal/pages")
folder = next((p for p in pages if p["kind"] == "pasta" and p["title"] == "Script diary"), None)
if folder is None:
folder = paper("/vaults/principal/pages", "POST", {"title": "Script diary", "kind": "pasta"})
if not any(p["parentId"] == folder["id"] and p["title"] == today for p in pages):
paper("/vaults/principal/pages", "POST", {
"title": today,
"parentId": folder["id"],
"markdown": "## For today\n\n- [ ] \n\n## Notes\n",
})
```
## Append to a page [#append-to-a-page]
```bash
paper /vaults/principal/pages/pa1k2m3n4o5p -X PATCH \
-d '{"append": "- [ ] Call the supplier @2026-10-07 10:00"}'
```
## Read a whole folder for an AI [#read-a-whole-folder-for-an-ai]
```python
def folder_text(vault, folder_id):
parts = []
for p in paper(f"/vaults/{vault}/pages?parent={folder_id}"):
if p["kind"] == "pagina" and not p.get("locked"):
page = paper(f"/vaults/{vault}/pages/{p['id']}")
parts.append(f"# {page['title']}\n\n{page['markdown']}")
return "\n\n---\n\n".join(parts)
```
Folders with many pages spend one request per page. For 60 pages or more, spread the reads over a few minutes.
## Create an event from a task [#create-an-event-from-a-task]
```js
await paper('/calendar/events', {
method: 'POST',
body: { title: 'Call the supplier', date: '2026-10-07', time: '10:00', durationMinutes: 15 },
});
```
## Upload an image and put it in a page [#upload-an-image-and-put-it-in-a-page]
```bash
RESPONSE=$(curl -sS -X POST "https://wire.ia.br/api/v1/vaults/principal/files?name=chart.png" \
-H "Authorization: Bearer $PAPER_TOKEN" \
-H "X-Paper-Account: $PAPER_ACCOUNT" \
-H "Content-Type: image/png" \
--data-binary @chart.png)
MD=$(echo "$RESPONSE" | jq -r .markdown)
paper /vaults/principal/pages/pa1k2m3n4o5p -X PATCH -d "$(jq -n --arg md "$MD" '{append: $md}')"
```
## A tool for an agent (Claude, OpenAI and others) [#a-tool-for-an-agent-claude-openai-and-others]
A tool definition in JSON Schema format, which most models accept:
```json
{
"name": "paper_append",
"description": "Appends Markdown text to the end of a page in the person's Paper notebook.",
"input_schema": {
"type": "object",
"properties": {
"vault": { "type": "string", "description": "Vault id, from GET /vaults" },
"page": { "type": "string", "description": "Page id, from GET /vaults/{vault}/pages" },
"text": { "type": "string", "description": "Markdown to append" }
},
"required": ["vault", "page", "text"]
}
}
```
When executing, call `PATCH /vaults/{vault}/pages/{page}` with `{"append": text}`.
---
# Page format
Source: https://wire.ia.br/documentation/en/api/formato-das-paginas
> The Markdown the API reads and writes, with tables, boards, timelines, charts, dates and links.
Each page is plain Markdown, readable in any editor. Blocks Markdown doesn't have become code blocks with their own names, and the app turns them back into interactive blocks.
Block names and keywords (`paper-kanban`, `tipo`, `título`, `[!nota]`) stay the same in every language, because they are part of the file format.
## Basics [#basics]
````md
## Section heading
Text with **bold**, *italic*, ~~strikethrough~~ and `code`.
- List
1. Numbered list
- [ ] Open task
- [x] Done task
> Quote
> [!nota]
> Highlight (callout)
```js
console.log('code block')
```
---
````
## Links, dates and attachments [#links-dates-and-attachments]
| Write | Becomes |
| ------------------------------------------- | ------------------------------------------------------------ |
| `[[Page name]]` | Link to another page in the vault |
| `[[Page name\|text]]` | Link with different text |
| `@2026-10-06` | Date. On a task, it shows in the app's Calendar |
| `@2026-10-06 14:30` | Date with a time |
| `` | Image uploaded through the [attachments API](/en/api/anexos) |
| `#tag` | Tag, which shows in the app's search filters |
Dates in the file are always `YYYY-MM-DD`, whatever language the app is in.
## Table [#table]
A regular Markdown table. An optional comment before it keeps the type of each column (`texto`, `numero`, `data`, `check`, `opcao`):
```md
| Task | Due | Done |
| --- | --- | --- |
| Budget | 2026-10-06 | sim |
```
## Board (Kanban) [#board-kanban]
Each `##` is a column; each item is a card.
````md
```paper-kanban
## To do
- [ ] Review contract
## Doing
- [ ] Write report
## Done
- [x] Schedule meeting
```
````
## Timeline [#timeline]
One stage per line: start, end and name.
````md
```paper-cronograma
- [x] 2026-10-01 → 2026-10-05 · Plan
- [ ] 2026-10-04 → 2026-10-15 · Build
- [ ] 2026-10-14 → 2026-10-20 · Review
```
````
`->` and `até` also work in place of `→`.
## Chart [#chart]
Type (`barras` bars, `linhas` lines, `area`, `pizza` pie), an optional title and a small table separated by `;`. The first line gives the series names.
````md
```paper-grafico
tipo: barras
título: Quarter spending
Month; Groceries; Transport
Jul; 820; 210
Aug; 790; 180
Sep; 845; 230
```
````
## Frontmatter [#frontmatter]
The page's properties sit in a `---` block at the top of the file. The API returns those properties in `props`, and you don't need to send the frontmatter when creating or editing: send only the text.
## Protected pages [#protected-pages]
In the `.md` file, a password-protected page becomes an encrypted block that only the app opens with the password. The API neither reads nor writes these pages (`423`).
---
# Limits
Source: https://wire.ia.br/documentation/en/api/limites
> How many requests, how many files and what size.
| Limit | Value | Applies to |
| -------------------------- | ----- | ---------------------------------- |
| Requests per minute | 60 | Each token |
| Requests per day | 5000 | Each token, resets at midnight UTC |
| File uploads per day | 30 | Each token |
| Size of one file | 10 MB | Each upload |
| Text of one page | 1 MB | `markdown` and `append` |
| Body of a JSON request | 2 MB | Each request |
| Active tokens | 20 | Each account |
| Text of a vault for a copy | 20 MB | Secure token |
| Pages in a copy | 6000 | Secure token |
| Search results | 50 | Each search |
| Events per listing | 250 | Calendar |
The limits also show in `GET /me`, in the `limites` field.
## When you go over a limit [#when-you-go-over-a-limit]
The API answers `429` with a message saying which limit was reached. The message follows `Accept-Language`:
```json
{ "error": "Limit of 60 requests per minute. Wait a moment." }
```
Wait and try again, with growing intervals: 2 seconds, then 4, 8, 16. If it's the daily limit, stop until the next day.
## Normal use [#normal-use]
Normal use, like an assistant that organizes notes or a script that creates the day's page, stays far below these numbers. Getting around limits with several tokens or several accounts violates the terms and leads to a ban. See [Fair use](/en/termos/uso-justo).
If you have a real case that needs more, write to [support](https://wire.ia.br/en/support/) and choose the subject **API and access tokens**.
---
# Developer mode
Source: https://wire.ia.br/documentation/en/api/modo-desenvolvedor
> The switch that unlocks tokens, file uploads, calendar changes and remote automations.
The app stays the same with developer mode on. It only unlocks access tokens. Without it, no token works, not even existing ones.
## Turn it on [#turn-it-on]
Open **Settings → Developer**.
Read the [API terms of use](/en/termos/termos-da-api), check the acceptance box and tap **Turn on developer mode**.
Copy your account ID, shown at the top. It goes in the `X-Paper-Account` header and confirms the token is yours. See [Authentication](/en/api/autenticacao).
## Allow Google for the API [#allow-google-for-the-api]
Regular tokens read and write in the real vaults through your Google Drive. For that, the server needs to keep your Google connection.
* **Google Drive for the API**: connect Google in **Sync** and tap **Allow this device's connection for the API**.
* **Calendar for the API**: connect Google Calendar in **Integrations** and tap **Allow the "Paper" calendar for the API**.
The server only acts on your Drive and calendar when one of your tokens is used. Secure tokens need none of this.
## What the mode unlocks [#what-the-mode-unlocks]
| Feature | Without the mode | With the mode |
| ---------------------------------------------------- | ---------------- | ---------------------------- |
| Access tokens | Don't work | Up to 20 active |
| Reading and writing pages from a program | No | Where the token allows |
| Uploading files through the API | No | Up to 30 per day, 10 MB each |
| Creating and deleting events in the "Paper" calendar | No | If the token allows |
| Remote automations (scripts, servers, agents) | No | Yes |
## When the terms change [#when-the-terms-change]
If the API terms get a new version, your tokens pause until you accept it in **Settings → Developer**. The API answers `403` with a message saying so.
## Turn it off [#turn-it-off]
**Turn off developer mode** revokes all tokens right away, deletes the copies for AI and deletes the Google connection stored on the server. Your notes don't change.
## Banned account [#banned-account]
If the account is banned for violating the terms, all tokens are revoked, published links are taken down and the Google connection stored on the server is deleted. See [Bans and appeals](/en/termos/banimento-e-apelacao).
---
# Access tokens
Source: https://wire.ia.br/documentation/en/api/tokens
> The two kinds of token, the permissions of each, and how to keep and revoke them.
A token is a key you hand to a program. It has this format:
```txt
paper_k3m9x2ab_Q7wLc2…(40 characters)
```
* `paper_` marks it as a Paper token. Tools that look for leaked secrets recognize this prefix.
* The 8 characters in the middle identify the token. They show up in the token list, so you know which is which.
* The last 40 are the secret. The server keeps only a digest (hash) of it, so not even Paper can show the token again. If you lose it, revoke it and create another.
## The two kinds [#the-two-kinds]
| | Secure (for AI) | Regular |
| -------------------------------- | ---------------------------------- | ------------------------------------- |
| What for | Giving a vault to an AI to work on | Your own automations |
| What it reaches | An isolated copy of one vault | The real vaults, through Google Drive |
| Changes | Wait for your review | Take effect right away |
| Calendar and files | No | If you allow |
| Needs Google allowed for the API | No | Yes |
When in doubt, use **secure**. If the AI makes a mistake, the real vault stays intact.
## Permissions [#permissions]
When creating a regular token, you choose:
| Permission | Options |
| ---------------- | -------------------------------------------------------------------- |
| Each vault | No access, Read, Read and edit |
| Protected pages | Hide (the token doesn't even know they exist) or Show only the title |
| "Paper" calendar | No access, Read events, Read and create events |
| Send files | Yes or no |
| Expiry | 7 days, 30 days, 90 days or no expiry |
Even with "Show only the title", the content of protected pages never leaves: the request answers `423`.
The secure token has fixed permissions: it reads and edits only its own copy.
## See how the token looks to the API [#see-how-the-token-looks-to-the-api]
```bash
curl https://wire.ia.br/api/v1/me -H "Authorization: Bearer $PAPER_TOKEN"
```
```json
{
"conta": { "id": "3f2a…(32 characters)", "nome": "Ana" },
"token": {
"id": "k3m9x2ab",
"nome": "Task script",
"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"
}
```
Field names and values are in Portuguese: `tipo` is `seguro` (secure) or `normal` (regular); vault access is `ler` (read) or `editar` (edit); `protegidas` is `ocultar` (hide) or `titulo` (title only); `agenda` is `nenhum`, `ler` or `editar`.
## Keep it safe [#keep-it-safe]
* Keep it in an environment variable or a password manager. Never in public code, screenshots or group messages.
* One token per program. That way, revoking one doesn't take down the others.
* Give only the permissions the program needs.
## Revoke [#revoke]
In **Settings → Developer → Active tokens**, tap **Revoke**. The token stops working on the next request. The list also shows when each token was last used and how many times.
A leaked token used for abuse leads to the ban of the account that owns it. If you suspect a leak, revoke it before anything else.
---
# API overview
Source: https://wire.ia.br/documentation/en/api/visao-geral
> What the personal API does, who it's for and the shortest path to your first request.
The personal API lets a program or an AI agent read and write in **one person's** notebook, with a token that person created and can revoke at any time. There's no API to read data from other accounts, and no third-party access without a token.
```txt
Base: https://wire.ia.br/api/v1
Format: JSON (UTF-8). Files: binary body.
Authentication: Authorization: Bearer paper_…
Error language: Accept-Language: en (or pt-BR, es)
```
The API field names are in Portuguese (`conta`, `titulo`, `permissoes`…), the same for every language. Error messages follow `Accept-Language`.
## The shortest path [#the-shortest-path]
**Turn on developer mode** in Settings → Developer and accept the [API terms](/en/termos/termos-da-api). See [Developer mode](/en/api/modo-desenvolvedor).
**Create a token.** Choose the type (secure for AI, regular for automations), the vaults and what it can do. See [Tokens](/en/api/tokens).
**Make your first request:**
```bash
curl https://wire.ia.br/api/v1/me \
-H "Authorization: Bearer $PAPER_TOKEN" \
-H "X-Paper-Account: $PAPER_ACCOUNT" \
-H "Accept-Language: en"
```
The response shows the account, the token's permissions and the limits.
## What you can do [#what-you-can-do]
| Area | Endpoints | Page |
| ---------------- | ---------------------------------------------------------------------------------------------- | -------------------------------------------- |
| Account | `GET /me` | [Authentication](/en/api/autenticacao) |
| Vaults and pages | `GET /vaults`, `GET/POST /vaults/{vault}/pages`, `GET/PATCH/DELETE /vaults/{vault}/pages/{id}` | [Vaults and pages](/en/api/cofres-e-paginas) |
| Search | `GET /vaults/{vault}/search?q=` | [Search](/en/api/busca) |
| Files | `POST /vaults/{vault}/files?name=` | [Attachments](/en/api/anexos) |
| Calendar | `GET/POST /calendar/events`, `DELETE /calendar/events/{id}` | [Calendar](/en/api/agenda) |
## Where the data lives [#where-the-data-lives]
Personal notes aren't stored on the Paper server. They live on the person's device and in their Google Drive. So:
* **Regular token**: the server reads and writes in the person's Google Drive at request time, using the connection they allowed for the API. Only vaults synced with Drive show up.
* **Secure token**: the server keeps an isolated copy of one vault, created when the person made the token. The AI works on that copy, and the person decides what to bring into the real vault. See [Copies for AI](/en/api/copias-para-ia).
## What no token does [#what-no-token-does]
* Open password-protected pages (`423`).
* Read groups, which are end-to-end encrypted.
* Touch the account, sessions, friendships or settings.
## For AI agents [#for-ai-agents]
The full documentation map, with rules and endpoints, is at [`/documentation/agents/raw.json`](https://wire.ia.br/documentation/agents/raw.json). Before acting, read [AI agents](/en/api/agentes-de-ia).
---
# Vaults, folders and pages
Source: https://wire.ia.br/documentation/en/guia/cofres-pastas-e-paginas
> Three ways to organize, from the biggest to the smallest.
## Vaults [#vaults]
A vault is a whole notebook, separate from the others: its own pages, search, map and calendar. Use it to separate worlds that don't mix, like work and personal life.
* Switch vaults from the top of the sidebar.
* Each vault syncs to its own folder inside the Paper folder of your Google Drive.
* Every notebook starts with the **main** vault.
## Folders [#folders]
Folders hold pages and other folders. A folder has no text: when you open it, it shows what's inside, with buttons to create a page, create a folder and import `.md` files right there.
* **Create**: folder button at the top of the sidebar, or **New folder** inside another folder. A new folder opens with its name selected, so you can just type over it.
* **Move**: drag in the sidebar, or use **Move** in the page menu.
* **In Google Drive**: each Paper folder becomes a real folder, with the page files inside.
## Pages inside pages [#pages-inside-pages]
A page can also have pages inside it, like chapters. The difference from a folder is that the parent page has its own text.
| I want to… | Use |
| --------------------------------- | ---------------------- |
| Keep work and personal life apart | Vaults |
| Group several pages by subject | Folder |
| A document with chapters | Page with pages inside |
## Favorites, Inbox and Journal [#favorites-inbox-and-journal]
* **Favorites** stay at the top of the sidebar. Use the star at the top of the page.
* **Inbox** receives what you jot down quickly with Ctrl Shift Space.
* **Today** opens the page for the day, inside the Journal folder.
---
# Start here
Source: https://wire.ia.br/documentation/en/guia/comece-por-aqui
> Your first ten minutes in Paper, step by step and without jargon.
When you create your account, the notebook already comes with the **Start here** page and a **Guides** folder. They repeat what's on this page, inside the app itself. You can delete them whenever you want: the guides stay in **Settings → About → Guides**.
### Write [#write]
Click any line and write. Enter creates a new line. There's no save button: Paper saves on its own, on this device, even without internet.
### Pick the line type with the / bar [#pick-the-line-type-with-the--bar]
On an empty line, type `/` and choose: heading, list, task, quote, callout, table, board, timeline, chart, image or file.
### Link one page to another [#link-one-page-to-another]
Type `[[` and the name of a page. The link follows the page when you rename it. At the end of each page you see where it was mentioned.
### Add dates [#add-dates]
Type `@` and a date, like `@tomorrow 2pm`. The line shows up in the **Calendar** on the right day. Paper understands dates in English, Portuguese and Spanish.
### Organize in folders [#organize-in-folders]
In the sidebar, the folder button creates a new folder. Drag pages into it. Folders can live inside folders.
### Take it to other devices [#take-it-to-other-devices]
In **Settings → Sync**, connect Google Drive once. Each page becomes a file in the Paper folder of your Drive, and your phone and computer stay the same. See [Sync with Google Drive](/en/guia/sincronizar).
## Shortcuts worth knowing [#shortcuts-worth-knowing]
| Shortcut | What it does |
| ---------------- | ------------------------------------------ |
| Ctrl K | Search anything |
| Ctrl Z | Undo, even deleting a page |
| Ctrl Shift Space | Quick note, without picking a page |
| Ctrl Shift L | Switch between reading and editing |
| Esc | Select the block; Shift ↑↓ selects several |
On a Mac, use Cmd instead of Ctrl.
## Quick notes [#quick-notes]
Ctrl Shift Space opens a small box to write without thinking about where to keep it. Everything lands in the **Inbox**, and you organize it later.
## Your language [#your-language]
The app speaks English, Portuguese and Spanish. Change it in **Settings → Appearance → Language and region**: the choice applies to all your devices. Dates, times and numbers follow your region.
## Next steps [#next-steps]
* [Writing and reading](/en/guia/escrever-e-ler): blocks, reading mode and page templates.
* [Vaults, folders and pages](/en/guia/cofres-pastas-e-paginas): how to keep work, study and personal life apart.
* [Privacy and security](/en/guia/privacidade-e-seguranca): password pages and what Paper can see.
---
# Share a page
Source: https://wire.ia.br/documentation/en/guia/compartilhar
> Public read-only links, with a plain text version for AIs and programs.
The **Share** button at the top of the page creates a link to it. Whoever opens the link sees only that page, in reading mode, without needing an account.
## Options [#options]
* **Expiry**: 1 day, 7 days, 30 days or never.
* **Live**: the link follows your changes a few seconds later. When off, the link shows the page as it was when you published, and you update it whenever you want.
* **Take down**: the link stops working right away.
All published links are in **Settings → Published links**.
## Plain text for AIs and programs [#plain-text-for-ais-and-programs]
Every link has two versions without styling, good for pasting into an AI or reading from a program:
| Address | What it returns |
| -------------------------------- | ------------------------------------------------------------- |
| `https://wire.ia.br/s/code` | The page for people |
| `https://wire.ia.br/s/code.md` | Just the Markdown |
| `https://wire.ia.br/s/code.json` | Title, plain text, Markdown, blocks, language and update date |
The share window has buttons to copy each version.
The page keeps the language it was written in. What's around it (top bar, date, footer) shows up in the language of whoever visits.
## What can't be shared [#what-cant-be-shared]
* **Password-protected pages.** Remove the password first if you really want to publish.
* **Illegal content, spam or other people's personal data.** Links like that are taken down and the account is banned. See the [terms](/en/termos/uso-justo).
## What stays on the server [#what-stays-on-the-server]
The text of a shared page is stored on the Paper server, without encryption, while the link exists. That's the price of anyone being able to open it. When you take it down or it expires, the copy is deleted.
Links don't show up on Google or other search engines.
## Report a page [#report-a-page]
Found a Paper link with content that violates the terms? Use the **Report** link in the footer of the published page, or open [support](https://wire.ia.br/en/support/) and choose the subject **Report a published note**.
---
# Writing and reading
Source: https://wire.ia.br/documentation/en/guia/escrever-e-ler
> Blocks, edit mode, reading mode, templates and each page's menu.
## Blocks [#blocks]
Each line of a page is a block. The `/` bar on an empty line shows every type:
| Block | What for |
| ------------------- | ----------------------------------------------------------------------------------- |
| Text, headings | The basics. `#`, `##` and `###` at the start of a line also become headings. |
| List, numbered list | `-` or `1.` at the start of a line. |
| Task | `[ ]` at the start of a line. Shows up in the Calendar if it has a date. |
| Quote and callout | To draw attention to a passage. |
| Code | Fixed-width text, with color by language. |
| Table | Columns with a type (text, number, date, checkbox, option) and a sum at the bottom. |
| Board | Columns with cards you drag around, like a Kanban. |
| Timeline | Steps with a start and an end on a timeline. |
| Chart | Bars, lines, area or pie, from a small table. |
| Image and file | Drag from your computer onto the page. |
Dragging a `.md` or `.txt` file into a page brings its text in as blocks. Other files become attachments.
The `/` bar understands block names in English, Portuguese and Spanish: `/table`, `/tabela` and `/tabla` all work.
## Edit mode and reading mode [#edit-mode-and-reading-mode]
The **Read** button at the top of the page turns on reading mode. In it, no click changes the text: good for looking things up on your phone, presenting in a meeting or reviewing without fear. Tasks and boards are locked too.
* **Ctrl Shift L** switches between reading and editing.
* Paper remembers the choice for each page.
* To open everything in reading mode by default: **Settings → Editor → Open pages in reading mode**.
## Templates [#templates]
An empty page shows ready templates: meeting, project, task list, book reading, study and week plan. Click one to start with the structure in place.
## Page menu [#page-menu]
The three dots at the top of the page open the menu:
* **Icon**: pick an emoji that shows in the sidebar and above the title.
* **Duplicate**: creates a copy right below.
* **Move**: takes the page to another folder or into another page.
* **Copy internal link**: copies the `[[link]]` to paste in another page.
* **Share**: creates a public link. See [Sharing](/en/guia/compartilhar).
Next to the edit date, the page shows how many words it has and how long it takes to read.
## Download a page [#download-a-page]
The export button at the top of the page downloads just that page, as `.md`, PDF or Word.
---
# Groups and friends
Source: https://wire.ia.br/documentation/en/guia/grupos
> Team notes, end-to-end encrypted, edited at the same time.
The personal notebook and groups are kept apart. What's yours stays yours; what belongs to the group stays in the group's space. Switch between them with the selector at the top of the sidebar, the same one used for vaults. **New group** is at the end of that list.
## Friends [#friends]
Each account has a 32-character ID, in **Settings → Profile**. To add someone:
* **By ID**: the person gives you their ID and you send a request.
* **By invite**: create a link in **Settings → Friends**, with a deadline and a number of uses. Whoever opens the link becomes your friend.
In **Friends** you choose who can send you requests (anyone or link only) and block whoever you want.
## Groups [#groups]
A group is a shared space of pages. Everyone in the group sees the same pages and edits at the same time, seeing who's on each page.
| Role | What they can do |
| ------ | ---------------------------------------------------- |
| Owner | Everything, including deleting the group |
| Admin | Invite, remove and change roles of people below them |
| Editor | Create and edit pages |
| Reader | Read only |
Groups need internet, since editing is live. The personal notebook works without it.
## End-to-end encryption [#end-to-end-encryption]
Group content is encrypted on the device before it leaves. The Paper server relays and stores only scrambled data, without the key to open it. That's why:
* No access token reads groups.
* If everyone in the group loses the key, nobody can recover the content, not even Paper.
## No chat [#no-chat]
Paper has no chat. The focus is writing together: to agree on something about a page, write it on the page itself.
---
# Import .md files
Source: https://wire.ia.br/documentation/en/guia/importar
> Bring in Markdown notes, whole folders and .zip files.
Paper reads plain Markdown. You can bring a single note, a folder full of notes or a `.zip` exported from another app.
## Ways to import [#ways-to-import]
Drag `.md` files from your computer to the sidebar. Dropping them on a folder puts them inside it. Dropping them inside an open page brings the text in as blocks at that point.
Open a folder and use **Import .md here**. The chosen files go inside it.
**Settings → Import and export → Import**. It accepts `.md` and `.txt` files, whole folders and `.zip`, even a `.zip` inside a `.zip`. Before importing, Paper shows how many pages and attachments will come in.
## What comes along [#what-comes-along]
* **Folders and subfolders** become Paper folders, in the same order.
* **Frontmatter** (the `---` block at the top) becomes page properties.
* **Links** like `[[Page]]` and Markdown links between files become Paper links.
* **Images and attachments** mentioned in the notes, like `![[photo.png]]` or ``, come along. Files no note mentions are left out.
* **Tasks, tables, callouts and code blocks** stay the same.
Each attachment can be up to 25 MB.
## Export [#export]
In **Settings → Import and export**, the **Export the whole vault** option creates a `.zip` with every page as `.md`, organized in folders. It's the same format that goes to Google Drive. To download a single page, use the export button at its top (`.md`, PDF or Word).
---
# Privacy and security
Source: https://wire.ia.br/documentation/en/guia/privacidade-e-seguranca
> Where notes are kept, what the server sees and how to lock a page.
## Where each thing is kept [#where-each-thing-is-kept]
| What | Where | Does the Paper server read it? |
| ---------------------------------------- | -------------------------------------- | ------------------------------------------- |
| Personal notes | On the device and in your Google Drive | No |
| Password-protected pages | Encrypted, on the device and in Drive | No, not even with the wrong password |
| Groups | Encrypted on the server | No, it only relays them |
| Published links | On the server, in plain text | Yes, to show them to whoever opens the link |
| Copies for AI (secure token) | On the server, in plain text | Yes, while the copy exists |
| Account, language, friendships, sessions | On the server | Yes |
## Protected pages [#protected-pages]
The lock at the top of a page locks the content with a password of yours. The page is encrypted on the device with a key derived from the password and a random salt, so:
* Not even Paper can open it without the password. Keep it safe: there's no recovery.
* No access token opens protected pages. The API answers `423`.
* Protected pages can't be published by link.
## Access tokens [#access-tokens]
A token only does what you checked when creating it: which vaults, read or edit, calendar and attachments. You revoke it in **Settings → Developer**, and it stops right away. Details in [Tokens](/en/api/tokens).
## Sessions [#sessions]
In **Settings → Account and security** you see the connected devices and end the ones you don't recognize.
## Automatic translation [#automatic-translation]
If you use your browser's automatic translation (for languages Paper doesn't speak natively), Paper marks your notes and page titles so the translator leaves them out. Only the app's buttons and menus get translated.
## More [#more]
* [Privacy Policy](https://wire.ia.br/en/privacy/)
* [Terms of Use](https://wire.ia.br/en/terms/)
* [Cookies and local storage](https://wire.ia.br/en/cookies/)
---
# Sync with Google Drive
Source: https://wire.ia.br/documentation/en/guia/sincronizar
> Connect once per device and Paper keeps your phone and computer the same.
Paper saves everything on the device first. Sync copies each page to the **Paper** folder of your Google Drive and brings back what changed on another device.
## Connect [#connect]
Open **Settings → Sync** and tap **Connect Google on this device**.
A Google window opens. Pick the account and accept. Paper only asks for access to the files it creates itself in Drive and to its own calendar called Paper. It can't see the rest of your Drive or your other calendars.
Done. The connection stays saved on this device and doesn't expire on its own. Repeat once on each device you use.
## What it looks like in Drive [#what-it-looks-like-in-drive]
```txt
Paper/ ← main vault
Start here.md
Guides/
Coming from Obsidian.md
Anexos/
a1b2c3d4e5-photo.png
Paper · Work/ ← another vault
...
```
The main vault lives in the **Paper** folder, and each other vault gets its own, **Paper · vault name**. Each Paper folder becomes a Drive folder, and each page becomes a `.md` file any editor opens. Attachments go to the `Anexos` subfolder (the name stays the same in every language, so links keep working).
If the same page changes on two devices before syncing, the version from the device that synced last stays, and the other becomes a "(other version)" copy. Nothing is lost.
## If you see "Not connected yet" [#if-you-see-not-connected-yet]
Google may cut off access if you change your Google account password, remove Paper at [myaccount.google.com/permissions](https://myaccount.google.com/permissions) or go many months without using it. In those cases, tap **Connect** again. Nothing is lost: what you wrote meanwhile stays on the device and goes up as soon as the connection is back.
Without internet, Paper keeps saving on the device and tries to sync again on its own when the connection comes back.
## Disconnect [#disconnect]
In **Settings → Integrations**, **Disconnect Google** deletes this device's connection and tells Google to cancel the access. The files already in your Drive stay there.
## Who keeps the connection [#who-keeps-the-connection]
The key that keeps the connection lives on your device, sealed: only the Paper server can open it, and only at the moment of renewing access. The server doesn't keep this key, unless you turn on [developer mode](/en/api/modo-desenvolvedor) and authorize the API to use your Drive.
---
# Coming from another app
Source: https://wire.ia.br/documentation/en/guia/vindo-de-outros-apps
> For people who used Obsidian or Notion. How to bring your notes and where each thing went.
If you're coming from a Markdown vault, almost everything works the same.
### Bring your vault [#bring-your-vault]
1. **Settings → Import and export → Import**.
2. Choose the vault folder or a `.zip` of it. Folders, subfolders, links, frontmatter, callouts, tasks, tables and images come along.
3. If you'd rather keep it separate, first create a new vault from the top of the sidebar and import there.
### Where each thing went [#where-each-thing-went]
| You used | In Paper |
| ------------------------------------------------- | -------------------------------------------------------------- |
| Vault | Vault, switched from the top of the sidebar |
| `[[Link]]`, `[[Link\|alias]]`, `[[Link#section]]` | The same, and they follow when you rename |
| Backlinks | "Mentioned in", at the end of the page, with unlinked mentions |
| Graph view | Idea map, with the "around one page" mode |
| Daily notes | Today button, one page per day inside Journal |
| Command palette | Ctrl K, with filters like `#tag` and open tasks |
| Callouts `> [!note]` | Callout block, and the `.md` keeps `> [!note]` |
| Kanban plugin | Board block, built in |
| Sync | Free Google Drive, or groups with live editing |
### What's not there yet [#whats-not-there-yet]
* Canvas and queries that combine many pages.
* Third-party plugins. For automations, use [access tokens](/en/api/tokens).
If you're coming from a workspace with pages and databases, this is the shortest path.
### Bring your pages [#bring-your-pages]
1. In the app you're coming from, export the workspace as **Markdown & CSV**.
2. In Paper: **Settings → Import and export → Import**, and pick the `.zip`. It can be a `.zip` inside a `.zip`.
3. The 32-letter codes at the end of the names disappear on their own, and links between pages become `[[links]]`.
### Where each thing went [#where-each-thing-went-1]
| You used | In Paper |
| ------------------ | ------------------------------------------------------------ |
| Pages and subpages | The same, and now real folders too |
| `/` for blocks | The same: `/` opens the list of blocks |
| Simple table | Table block, with column types and sums |
| Board | Board block |
| Timeline | Timeline block |
| `@date` | `@date` becomes a date in the Calendar |
| Teamspace | Groups, end-to-end encrypted, with simultaneous editing |
| Share to web | Share button, with a plain text version for AIs |
| AI assistant | Access tokens: your AI reads and writes only where you allow |
### The main difference [#the-main-difference]
Your personal notes don't live on a Paper server. They stay on your device and, if you connect it, in your Google Drive, as `.md` files any editor opens.
### What's not there yet [#whats-not-there-yet-1]
* Databases that combine many pages.
* Exported `.csv` files are left out for now.
---
# Paper documentation
Source: https://wire.ia.br/documentation/en
> How to use the notebook, connect other devices and give programs and AI agents access with tokens.
Paper is a notebook app. You write, organize in vaults and folders, link one page to another and take everything to other devices through your Google Drive. Personal notes stay on your device and in your Drive, as `.md` files any editor opens.
This documentation has two parts. The **guide** is for people who use the app. The **personal API** is for anyone who wants a program or an AI to read and write in the notebook, only where the person allows.
## For AI agents [#for-ai-agents]
If you're an AI agent, start with the JSON map. It lists every page of this documentation, the address of its plain text version and the usage rules (keys in Portuguese, with English and Spanish translations of each page):
```txt
https://wire.ia.br/documentation/agents/raw.json
```
Every page here has the **View as plain text** button, which opens the page's clean Markdown. The whole English documentation in a single file is at [`/documentation/llms-full.en.txt`](https://wire.ia.br/documentation/llms-full.en.txt), and the index of all languages at [`/documentation/llms.txt`](https://wire.ia.br/documentation/llms.txt).
## Languages [#languages]
Paper speaks Portuguese, English and Spanish, in the app and in this documentation. For any other language, your browser's automatic translation works well starting from the English version.
## The rules in one sentence [#the-rules-in-one-sentence]
Paper is a safe place to think and take notes. Use it as a notebook, not as a database or file hosting. Anyone who violates the [API terms](/en/termos/termos-da-api) loses their account permanently, and only an accepted [appeal](/en/termos/banimento-e-apelacao) reverses it.
---
# Bans and appeals
Source: https://wire.ia.br/documentation/en/termos/banimento-e-apelacao
> When an account is banned, what happens to it and how to ask for a review.
## When we ban [#when-we-ban]
We ban accounts that violate the [terms of use](https://wire.ia.br/en/terms/) or the [API terms](/en/termos/termos-da-api). The most common cases:
* Using Paper as a database or file hosting.
* Getting around the API limits with several tokens or several accounts.
* Spam, scams or illegal content in published links.
* Trying to break in, take down or exploit flaws of the service.
## What happens [#what-happens]
A ban is permanent and cuts access right away:
* The account can't sign in anymore. Anyone who tries goes to the appeal page.
* All sessions are ended.
* All tokens are revoked and the copies for AI are deleted.
* All published links go offline.
* The Google connection stored on the server is deleted.
* The account loses access to groups. Their content stays with the other members.
## What stays yours [#what-stays-yours]
Your personal notes stay in your browser and in your Google Drive, in `.md` files. A ban doesn't delete any of that, and you can open those files in any editor.
## Appeal [#appeal]
A ban doesn't lift by itself. The only way to reverse it is an accepted appeal.
Open [wire.ia.br/en/appeal](https://wire.ia.br/en/appeal/).
Leave a contact for the reply, the account ID (32 characters, in Settings → Profile, if you know it) and explain what happened.
A person reads each appeal and answers through the contact you left, within 15 days.
One appeal per case. Sending several doesn't speed up the answer.
## Report [#report]
Saw a Paper link with content that violates the terms? Use the **Report** link in the footer of the published page, or [support](https://wire.ia.br/en/support/) with the subject **Report a published note**.
---
# API terms of use
Source: https://wire.ia.br/documentation/en/termos/termos-da-api
> The rules you accept when you turn on developer mode. Version of October 2, 2026.
These terms apply to access tokens and to Paper's personal API. They complete the app's [terms of use](https://wire.ia.br/en/terms/) and [privacy policy](https://wire.ia.br/en/privacy/). You accept this version when you turn on developer mode.
The Portuguese text is the original. These English and Spanish versions are provided for your convenience, and if there is any difference, the Portuguese version prevails.
## 1. What the API is for [#1-what-the-api-is-for]
The API lets programs and AI agents help you in your own notebook: read, organize, write, create tasks and events. It serves one person at a time, the owner of the token.
## 2. Your responsibility [#2-your-responsibility]
* The token is yours. Everything done with it counts as done by your account, including by an AI or a program of someone else to whom you gave the token.
* Keep the token carefully and revoke it right away if you suspect a leak.
* Check the permissions before handing over a token. Give only what's needed.
## 3. Allowed [#3-allowed]
* Reading, creating and editing notes where the token has permission.
* Organizing, summarizing, reviewing and turning notes into tasks, dates and events.
* Uploading files that are part of your notes, within the [limits](/en/api/limites).
* Automating your own routines, like the day's page or a weekly summary.
## 4. Forbidden [#4-forbidden]
* Using Paper as a database, queue, cache, log or storage for another system.
* Hosting images or files for other sites, apps or people to download, including through published links.
* Getting around limits with several tokens, several accounts or bursts of requests.
* Polling nonstop to detect changes (more than one check per minute).
* Publishing or sending spam, illegal content, abusive content or other people's personal data without authorization.
* Trying to open protected pages, read data from other accounts, test security flaws without authorization or overload the service.
* Reselling access or offering Paper's API as a service to third parties.
## 5. Consequence [#5-consequence]
Violating section 4 leads to the **permanent ban** of the account: tokens revoked, published links taken down and access ended. A ban doesn't lift by itself. Only an accepted [appeal](/en/termos/banimento-e-apelacao) reverses it.
Your personal notes stay on your device and in your Google Drive even after a ban: Paper doesn't delete files from your Drive.
## 6. Availability [#6-availability]
The API may change, have maintenance or go offline. Changes that break programs will be announced in [What's new](/en/ajuda/novidades) in advance, when possible. The limits may change to protect the service.
## 7. Changes to these terms [#7-changes-to-these-terms]
When these terms change, the app asks for a new acceptance before enabling tokens again.
## 8. Contact [#8-contact]
Paper and the API are offered by Israel de Jesus Silva, an individual, in Brazil.
Questions about these terms: [contato.brennoleon@gmail.com](mailto:contato.brennoleon@gmail.com) or [support](https://wire.ia.br/en/support/), subject **API and access tokens**.
---
# Fair use
Source: https://wire.ia.br/documentation/en/termos/uso-justo
> Paper is a notebook. What that means in practice.
Paper is a safe place to think, take notes and organize life. It was made to be used as a notebook, by people, with the help of programs and AIs when they want.
## Notebook use [#notebook-use]
* Notes, lists, diaries, studies, projects, minutes, drafts.
* Images and files that are part of those notes.
* Automations that help the person: creating the day's page, gathering tasks, summarizing the week.
## Use that doesn't fit [#use-that-doesnt-fit]
* **Database.** Storing thousands of records from a system, sensor data, logs or answers from other services.
* **File hosting.** Uploading images to use on other sites, apps or stores, or distributing files through published links.
* **Queue or integration between systems.** Using pages as messages between programs.
* **Accounts in series.** Creating several accounts or tokens to add up limits.
These uses weigh on everyone's service and lead to a permanent ban. See [Bans and appeals](/en/termos/banimento-e-apelacao).
## Cloud images [#cloud-images]
Today, the images in your notes stay on your device and in your Google Drive. Image hosting in Paper's cloud, for the paid plan, is a future feature and doesn't exist yet.
## When in doubt [#when-in-doubt]
If you don't know whether a use fits, ask first through [support](https://wire.ia.br/en/support/).