# A linha de comando exporter

Rode as suas exportações pelo Terminal, pelo cron, por ferramentas de backup e por agentes.

`exporter` é o app Exporter para Mac rodando sem janela. Ele usa as mesmas conexões, pastas de exportação, seleção e ajustes que você configurou no app, e grava no mesmo registro de exportação. Ele funciona com o app fechado e nunca pergunta nada: qualquer coisa que falte interrompe a execução com o código de saída 2 e uma linha dizendo o que fazer. Só no macOS.

## Instalar

1. Instale o Exporter pela Mac App Store ([download](https://exporter.dev/download)) e abra-o.
2. Conecte um app (Apple Notes, Bear, Logseq, Contatos, Mensagens ou Tempo de Uso) ou uma pasta de Documentos, e escolha a pasta de exportação dele ([primeiros passos](https://exporter.dev/docs/getting-started)). Essas autorizações só podem ser dadas no app.
3. No cartão Linha de Comando do app, clique em “copiar comando de instalação” e cole-o uma vez no Terminal.

O app roda em sandbox e não pode gravar no seu PATH, e é por isso que o último passo é colar uma linha. A linha instala o `exporter` em `/opt/homebrew/bin` quando essa pasta existe e pertence a você (sem sudo), senão em `/usr/local/bin` com sudo. Colar de novo é seguro; substitui o que estiver lá. `exporter help install` mostra a linha para o seu Mac.

## Fontes

`--source` aceita uma destas:

| fonte | também aceita | grava |
| --- | --- | --- |
| `apple` | `apple-notes`, `applenotes`, `notes` | markdown ou html |
| `bear` | | markdown ou html |
| `logseq` | | sempre markdown |
| `contacts` | `apple-contacts`, `addressbook` | sempre markdown |
| `messages` | `imessage`, `chats`, `conversations` | sempre markdown |
| `screentime` | `screen-time`, `usage` | sempre markdown, um arquivo por dia |
| `documents` | `docs`, `files`, `pdf` | os formatos marcados no cartão Documentos |

## Formatos

`--format` aceita `markdown` (ou `md`) ou `html`; maiúsculas e minúsculas não importam. Qualquer outra coisa para com `error: --format pdf: expected markdown | html` e o código 64.

- sem ele, `sync` grava cada app no formato definido no cartão dele (o Apple Notes e o Bear têm cada um o seu) e `export` grava o ajuste do app que exporta; `exporter help sync` e `exporter help export` mostram os atuais
- Logseq, Contatos, Mensagens e Tempo de Uso são sempre markdown, e Documentos grava os formatos marcados no seu cartão, então para eles `--format html` é ignorado com um aviso: `note: logseq export is always markdown, so --format is ignored for this source.`
- o Apple Notes grava uma página `.html` por nota ([o formato HTML](https://exporter.dev/docs/notes#markdown-and-html)), com os anexos copiados para `attachments/` ao lado dela e com link, sem front matter. O HTML do Bear é o texto simples da nota dentro de um `<pre>`, sem estilo, e as referências aos anexos ficam como texto Markdown: os arquivos são copiados, não vinculados
- o servidor MCP lê só arquivos markdown, então uma exportação que é só HTML fica invisível para ele
- o Apple Notes e o Bear gravam um formato por execução; só Documentos grava os dois numa mesma sincronização. Uma execução remove apenas arquivos antigos do seu próprio formato, então mudar de formato deixa os arquivos do outro na pasta. Para os dois formatos, dê a cada um a sua própria pasta:

```sh
exporter export --dest ~/Backups/notes-md   --format markdown
exporter export --dest ~/Backups/notes-html --format html
```

## sync

Roda a exportação que você configurou no app, uma vez, de forma incremental, nas pastas de exportação do app.

```sh
exporter sync [--source <source>]... [--format markdown|html] [--full] [--json] [--quiet]
```

| flag | o que faz | padrão |
| --- | --- | --- |
| `--source <source>` | só este app, pode ser repetida | todos os apps conectados; os não conectados são pulados |
| `--format markdown\|html` | só nesta execução, o ajuste do app não muda. Vai para a mesma pasta de exportação que o outro formato; para manter os dois, exporte cada um para a sua própria pasta com `export --dest` | o ajuste do app |
| `--full` | reexporta tudo. Remove apenas os arquivos que o Exporter gravou antes de gravar; todo o resto na pasta de exportação fica | desligada |
| `--json` | um resumo legível por máquina | desligada |
| `--quiet`, `-q` | só erros | desligada |

```sh
exporter sync --source apple
```

```text
apple notes: exporting…
apple notes: 1204 of 1204 exported · 3 removed · 18.2s · markdown → /Users/me/Documents/notes
```

A linha de resumo é `<source>: <succeeded> of <selected> exported`, depois, quando houver, `N failed`, `N removed` (arquivos de itens que foram apagados, renomeados ou movidos), `N attachment issues`, e então a duração, o formato e a pasta gravada.

Se o app está aberto, `sync` não exporta nada, sai com 0 e mostra `Exporter is running: real-time sync is live, the export root is already current.`

## export

Uma exportação avulsa para uma pasta à sua escolha, para cópias e scripts. Ela funciona normalmente com o app aberto.

```sh
exporter export --dest <folder> [--source <source>] [--format markdown|html] [--organize folders|tags|smart] [--folder "Name"]... [--tag name]... [--dry-run] [--json] [--quiet]
```

| flag | o que faz | padrão |
| --- | --- | --- |
| `--dest <folder>` | obrigatória. Precisa estar dentro de uma pasta autorizada no cartão Linha de Comando do app (“adicionar pasta…”). Uma autorização em `~/Backups` vale para todas as pastas abaixo dela | nenhum |
| `--source <source>` | o app a exportar | `apple` |
| `--format markdown\|html` | o formato desta execução | o ajuste do app |
| `--organize folders\|tags\|smart` | só Apple Notes: como as notas se organizam em pastas | o ajuste do app |
| `--folder "Name"` | só esta pasta do Apple Notes, pode ser repetida, nome comparado sem diferenciar maiúsculas | a seleção salva no app |
| `--tag name` | só esta tag, pode ser repetida, Apple Notes ou Bear | a seleção salva no app |
| `--dry-run` | mostra o que seria exportado, sem gravar nada | desligada |
| `--json`, `--quiet` (`-q`) | como em sync | desligada |

Sem `--folder` nem `--tag`, o Apple Notes e o Bear exportam a seleção salva no app. O Logseq exporta o grafo inteiro, o Contatos todos os cartões, o Mensagens todas as conversas, o Tempo de Uso todos os dias; para eles os filtros são ignorados com um aviso.

```sh
exporter export --dest ~/Backups/notes-$(date +%F)
exporter export --dest ~/Backups/work --folder "Work" --format html
exporter export --dest ~/Backups/bear --source bear --tag journal
exporter export --dest ~/Backups/people --source contacts
exporter export --dest ~/Backups/papers --source documents
exporter export --dest ~/Backups/notes --dry-run
```

```text
would export 100 apple notes · markdown → /Users/me/Backups/notes
```

## list

```sh
exporter list sources|folders|tags|dests [--source apple|bear] [--json]
```

| lista | o que mostra | JSON |
| --- | --- | --- |
| `sources` | cada app, conectado ou não, com a sua contagem. Documentos não aparece | `[{"source": "apple", "connected": true, "notes": 1204}, {"source": "messages", "connected": true, "conversations": 1532}, {"source": "bear", "connected": false}]`, com `pages` para logseq, `contacts`, e `days` para `screen-time` |
| `folders` | pastas do Apple Notes com a contagem de notas, recuadas por nível. `--source bear` é um erro (código 64) | `[{"name": "Work", "notes": 42, "level": 0}]` |
| `tags` | tags com contagens, do Apple Notes por padrão, do Bear com `--source bear` | `[{"name": "journal", "notes": 12}]` |
| `dests` | pastas em que `export --dest` pode gravar, mais a pasta de exportação de cada app | `[{"path": "/Users/me/Backups", "kind": "granted"}]`, em que `kind` é `granted`, `granted, volume not mounted` ou `export root (apple-notes)` |

```sh
exporter list folders --json
```

```json
[{"name": "Work", "notes": 42, "level": 0}]
```

## status

```sh
exporter status [--json]
```

```text
apple notes    connected · last export 2026-09-11 03:00
bear           not connected
logseq         not connected
contacts       not connected
messages       connected · last export 2026-09-11 03:01
screen time    not connected
documents      not connected
root (apple-notes)  /Users/me/Documents/notes
root (messages)  /Users/me/Documents/messages
destinations   /Users/me/Backups
version        3.24 · free · 100 of 100 free notes used
messages       free · 10 of 10 free conversations used
app            not running
```

Com `--json`: um objeto por app, chamados `apple-notes`, `bear`, `logseq`, `contacts`, `messages`, `screen-time`, `documents`, cada um `{"connected": true, "lastExport": "2026-09-11 03:00"}` (`null` quando nunca exportado); `destinations` (caminhos); `tier` (`full` ou `free`, o desbloqueio do Apple Notes) e `freeNotesUsed`; `contactsTier` e `freeContactsUsed`; `messagesTier` e `freeConversationsUsed`; `screenTimeTier` e `freeDaysUsed`; `appRunning`. Os horários são locais, `yyyy-MM-dd HH:mm`.

## log

As execuções de exportação recentes, as mais novas primeiro: o mesmo registro que o app mostra, de todas as pastas de exportação e pastas `--dest` autorizadas. Pastas datadas criadas dentro de uma pasta autorizada não são lidas; o registro delas fica em `<folder>/.exporter/`.

```sh
exporter log [--last N] [--json]
```

| flag | o que faz | padrão |
| --- | --- | --- |
| `--last N` | quantas execuções | 10 |
| `--json` | um objeto por execução | desligada |

```text
2026-09-11 03:00  apple-notes   1204/1204 exported  3 removed  clean  → /Users/me/Documents/notes
```

JSON: `[{"source", "finishedAt", "selected", "succeeded", "failed", "format", "status", "destination", "prunedFiles", "runError"}]`. `status` é `clean`, `warnings` (faltam anexos) ou `failures`.

## doctor

Verifica se a exportação sem janela vai funcionar e mostra uma linha por verificação: `ok`, `FAIL` com uma linha `fix:` abaixo, `warn`, ou `--` para informação.

```sh
exporter doctor
```

Ele verifica se o banco de dados de cada app conectado pode ser lido e se a pasta de exportação dele aceita gravação, se cada autorização de pasta guardada ainda resolve, se cada pasta `--dest` aceita gravação, o índice e o comando instalado. Ele termina com o nível da versão, se o app está aberto e a última falha, se houve alguma. O código 0 mostra `all good.`, o código 2 mostra `N problem(s) found.`

## report

Mostra um relatório de diagnóstico (versão do app, macOS e hardware, estado das conexões, execuções recentes, última falha; nenhum conteúdo de nota) e o copia para a área de transferência.

```sh
exporter report [--send] [--email <addr>]
```

| flag | o que faz | padrão |
| --- | --- | --- |
| `--send` | envia o relatório para nós e mostra `sent.`, ou `offline: queued, will send on the next run or app launch.` | desligada |
| `--email <addr>` | adiciona o seu endereço para podermos responder | nenhum |

## help e version

- `exporter help [topic]`: tópicos `sync`, `export`, `list`, `status`, `log`, `doctor`, `report`, `cron`, `install`. A ajuda de um comando mostra os seus ajustes atuais como padrões
- `sync`, `export`, `list`, `log` e `report` também aceitam `--help` ou `-h`
- `exporter version` (ou `--version`, `-v`) mostra `exporter 3.24`
- `exporter` sozinho num terminal mostra a visão geral e sai com 64

## Saída JSON

`--json` funciona em `sync`, `export`, `list`, `status` e `log`. A saída é formatada, com as chaves em ordem. Para `sync` e `export`, adicione `--quiet`: sem ela, as linhas de progresso e os avisos saem no stdout antes do JSON. `export` mostra um objeto de resumo, `sync` mostra `{"runs": [...]}` com um por fonte:

```json
{
  "attachmentIssues" : 0,
  "durationSec" : 18.2,
  "failed" : 0,
  "format" : "markdown",
  "root" : "/Users/me/Documents/notes",
  "runError" : null,
  "selected" : 1204,
  "source" : "apple-notes",
  "status" : "clean",
  "succeeded" : 1204
}
```

Com o app aberto, `sync` mostra a sua linha única e nenhum JSON. Os erros vão para o stderr como `error: <what happened and what to do>`.

## Códigos de saída

| código | significado |
| --- | --- |
| 0 | ok, inclusive uma execução que a cota gratuita encurtou |
| 1 | falhas na exportação: um item falhou, a execução encontrou um erro, ou ela selecionou itens e não gravou nenhum |
| 2 | falta configurar: app não conectado, pasta não autorizada, pasta ou tag não encontrada, nada para exportar; `doctor` encontrou problemas; o comando instalado está num formato antigo ou o app para o qual ele aponta não existe mais |
| 64 | uso incorreto: comando ou flag desconhecido, valor ausente ou inválido, `--folder` com o Bear, `list folders --source bear`, `exporter` sozinho num terminal |

## Onde ficam os arquivos

`sync` grava na pasta de exportação definida para cada app no Exporter, como `~/Documents/notes` ou `~/Documents/messages`; `export` grava em `--dest`. Uma pasta no nível da sua pasta pessoal ou um abaixo dela, como a própria `~/Documents`, ganha uma subpasta por app (`notes-export`, `messages-export` e assim por diante), e uma pasta mais funda é usada como está. A linha de resumo (depois da seta) e o `root` do JSON mostram a pasta real.

Cada pasta de exportação guarda `.exporter/last-export.json` e `.exporter/last-export.md` (a última execução) e `.exporter/history/` (as últimas 50 execuções). Apple Notes, Contatos, Mensagens, Tempo de Uso e Documentos também mantêm `.exporter/files.json`, cada arquivo que uma execução gravou: a próxima execução remove apenas arquivos listados ali que nenhum item produz mais (o Tempo de Uso nunca remove um arquivo de dia). O Bear e o Logseq também removem, na próxima execução, os arquivos de notas que você apagou, renomeou ou mudou de tag. As exportações do Apple Notes e do Logseq também recebem `bases/` com visualizações do Obsidian.

## Cota gratuita

A linha de comando tem as mesmas cotas que o app:

| app | grátis |
| --- | --- |
| Apple Notes | 100 notas |
| Contatos | 100 contatos |
| Mensagens | as 10 conversas mais recentes |
| Tempo de Uso | os 10 dias mais recentes na primeira sincronização, e só esses: os dias seguintes precisam do desbloqueio |
| Documentos | os 10 documentos modificados mais recentemente |
| Bear e Logseq | ilimitado |

Os itens já exportados continuam sendo ressincronizados grátis; a cota só impede os novos. Uma execução que chega a ela ainda exporta o que pode, sai com 0 e mostra um aviso (não com `--quiet`):

```text
note: 42 note(s) skipped: free version limit (100 of 100 free notes). upgrade in the app to export everything.
note: 58 contact(s) skipped: free version limit (100 of 100 free contacts). unlock contacts in the app to export everything.
note: 1522 conversation(s) skipped: free version limit (10 of 10 free conversations). unlock messages in the app to export everything.
note: 11 day(s) skipped: free version limit (10 of 10 free days). unlock screen time in the app to archive every day.
note: 5 document(s) skipped: free version limit (10 of 10 free documents). unlock documents in the app to convert every one.
```

`status --json` traz o nível e a contagem usada do Apple Notes, Contatos, Mensagens e Tempo de Uso. Cada app limitado é desbloqueado com a sua própria compra única dentro do Exporter, [com preço por país](https://exporter.dev/pricing), sem assinatura e sem checkout na web. A linha de comando lê a compra a cada execução; se a App Store não responder em 5 segundos, a execução continua na cota gratuita.

## Agendamento

`exporter help cron` mostra estas linhas com o caminho completo do comando no seu Mac: use-o, porque o PATH do cron pode não incluir a pasta de instalação. Num crontab, escape `%` como `\%`:

```sh
0 3 * * * exporter sync
0 3 * * * exporter export --dest ~/Backups/notes-$(date +\%F)
```

Para o Carbon Copy Cloner e outras ferramentas de backup, rode `exporter sync` como script prévio e decida pelo código de saída. O comando fica ativo durante toda a exportação, mesmo quando o macOS o suspende sem ninguém com sessão iniciada. Com o app aberto, com a janela aberta ou fechada, `sync` não faz nada: a sincronização em tempo real já mantém a pasta atualizada.

## Servidor MCP

É o app, não a linha de comando, que roda um servidor MCP local que permite ao Claude, Cursor, VS Code e outros clientes pesquisar e ler as suas exportações, em `http://localhost:8744/mcp`. [A página do servidor MCP](https://exporter.dev/docs/mcp) cobre tudo sobre ele, de como iniciá-lo às suas seis ferramentas.

## Solução de problemas

Rode `exporter doctor` primeiro; cada verificação que falha mostra a sua solução. A [Ajuda](https://exporter.dev/docs/help) também cobre as mensagens do app.

- `X is not authorized`: adicione a pasta (ou uma pasta acima dela) no cartão Linha de Comando e rode de novo. `exporter list dests` mostra o que está autorizado
- `apple notes is not set up. open Exporter and connect Apple Notes + an export folder.` (o mesmo para cada app): conecte-o no Exporter
- `sync` diz que o Exporter está aberto: não há nada a fazer, o app mantém a pasta atualizada. Use `export --dest` para uma cópia separada
- `no notes were written. run "exporter doctor" to check folders and permissions.`: a execução selecionou notas e não gravou nenhuma; `doctor` verifica as pastas e as permissões
- `bookmark broken`: a pasta foi movida, apagada ou o volume dela não está montado. Escolha-a de novo no app
- o comando instalado está num formato antigo, ou o cron e as ferramentas de backup veem o código 19: cole o comando de instalação de novo
- o app foi movido depois que você instalou o comando: cole o comando de instalação de novo
- desbloqueado, mas a execução diz free: a verificação da compra espera no máximo 5 segundos e depois continua na cota gratuita. Rode de novo
- um problema que o doctor não consegue explicar: `exporter report --send --email you@example.com`

## Related

- [MCP server](https://exporter.dev/docs/mcp): Connect Claude and other agents
- [For agents](https://exporter.dev/agents): Skills, command line and MCP for agents
- [Apple Notes](https://exporter.dev/docs/notes): Folders, fields, HTML and fixes
- [Changelog](https://exporter.dev/changelog): What changed in each version

---

human version: https://exporter.dev/pt-br/docs/cli
every page: https://exporter.dev/llms.txt