FOGO. MANUAL ← Página inicial

Manual do Fogo

Do primeiro pedido até uma coleção guardada em git. Se leres só uma secção, lê a das variáveis — é a parte que muda a forma de trabalhar, e a que mais confunde quem vem do Postman.

O primeiro pedido

Abre o Fogo e carrega em New Request, em cima à direita. Escreve um endereço na barra e carrega Enter.

Se tiveres um comando curl à mão — copiado da documentação de uma API ou das ferramentas do navegador — cola-o na barra de endereço. O Fogo reconhece-o e preenche o método, os cabeçalhos, o corpo e a autorização de uma vez. É a forma mais rápida de começar.

Experimenta agora

Cola isto na barra de endereço e carrega Enter:

curl -X POST https://httpbin.org/post \
  -H "Content-Type: application/json" \
  -d '{"nome":"teste"}'

Fica um pedido POST completo, com o cabeçalho e o corpo já preenchidos. O httpbin.org devolve o que recebeu, o que o torna útil para perceber exatamente o que foi enviado.

A resposta aparece por baixo, com o estado, o tempo e o tamanho. JSON vem formatado e colorido; imagens e PDF aparecem visíveis, sem ter de gravar nada.

Variáveis e camadas

Uma variável escreve-se {{assim}} e serve para não repetir o mesmo endereço ou o mesmo token em cada pedido. Escreve-se na barra de endereço, nos cabeçalhos, no corpo — em qualquer campo.

Clica numa variável e abre uma caixa para lhe dar valor. É o caminho mais rápido: não precisas de ir a lado nenhum primeiro.

As quatro camadas

Aqui está a parte que interessa. Um valor pode viver em quatro sítios, e o de baixo nesta lista ganha:

CamadaQuando se aplica
GlobalsSempre, em tudo. Não se seleciona — está sempre ligada.
ColeçãoNos pedidos dessa coleção, haja ou não ambiente escolhido.
AmbienteNo ambiente que estiver selecionado em cima.
CapturadoValores tirados de uma resposta. Duram até fechares o Fogo.

Duas APIs, um só ambiente

O problema clássico: tens duas coleções, cada uma com o seu servidor, e no Postman andavas sempre a trocar de ambiente. Aqui não precisas.

Coleção A   baseUrl = https://a.dev     ← na coleção
Coleção B   baseUrl = https://b.dev     ← na coleção
Ambiente Dev  token = ...              ← partilhado

Abres um pedido de A  →  usa a.dev
Abres um pedido de B  →  usa b.dev
Sem trocar nada.

O baseUrl pertence à coleção, não a uma coisa que andas a trocar. O token, esse sim, muda conforme o ambiente — e é por isso que fica no ambiente.

Onde escrever cada uma

  • Na coleção: clica com o botão direito na coleção → Variables…
  • Nas globals: painel dos ambientes, a linha Globals por cima da lista
  • Num ambiente: painel dos ambientes, o lápis na linha

Também podes fazer tudo a partir da caixa que abre ao clicar na variável: o campo Save in deixa escolher a camada.

Segredos

Marca uma variável como Secret e o valor passa a viver no gestor de credenciais do Windows, não na base de dados do Fogo. Fica mascarado no ecrã e é retirado do histórico, dos registos, das exportações e do código gerado. Uma variável marcada assim nunca chega a um ficheiro que possas commitar por engano.

Autorização

No separador Authorization de cada pedido. Os tipos disponíveis são No Auth, Basic Auth, Bearer Token, API Key, Digest Auth e OAuth 2.0.

Escrever uma vez para toda a coleção

É quase sempre o que queres. Botão direito na coleção → Collection settings… → separador Authorization. Depois, cada pedido fica em Inherit from collection — que já é o que vem por omissão — e usa o que puseste ali.

Assim o token está num sítio só. Mudou? Mudas uma vez, e não em quarenta pedidos.

OAuth 2.0

O Fogo trata dos fluxos que não precisam de navegador: client credentials e password. Pede o token sozinho, guarda-o em memória enquanto for válido e renova-o quando expira. O token nunca é escrito em disco.

O fluxo authorization code com PKCE ainda não existe, e por isso não aparece na lista. Preferimos não o oferecer a oferecê-lo sem funcionar.

O corpo do pedido

No separador Body: None, JSON, GraphQL, Text, Form Data e x-www-form-urlencoded.

O editor de JSON avisa quando falta uma chaveta ou uma vírgula — e entende {{variáveis}} pelo meio, sem as tratar como erro. Com Form Data podes anexar ficheiros.

Em GraphQL escreves a consulta e as variáveis em campos separados, e o Fogo monta o pedido como o servidor espera.

Trazer do Postman

Botão Import. Aceita coleções e ambientes do Postman, OpenAPI 3, Swagger 2 e comandos cURL — e reconhece o formato sozinho, sem teres de dizer qual é.

Podes arrastar o ficheiro, colar o conteúdo, ou largar o .zip que o Postman produz no Export Data.

As variáveis da coleção ficam na coleção, que é onde o Postman também as põe. Uma coleção importada funciona logo, sem teres de escolher um ambiente primeiro.

Antes de gravar, o Fogo mostra o que vai criar e avisa se algum {{...}} ficou por definir. Uma importação nunca altera nem apaga o que já lá está — só acrescenta.

Capturar valores de uma resposta

O caso do costume: fazes login, recebes um token, e queres usá-lo nos pedidos seguintes sem o copiar à mão.

No separador Extract do pedido de login, dizes de onde vem o valor e com que nome fica guardado. A partir daí, {{token}} resolve em qualquer pedido.

Login que alimenta o resto

Resposta do login   { "access_token": "eyJhbGciOi..." }

Extract             caminho  access_token
                    nome     token
                    guardar  This session only

Pedidos seguintes   Authorization: Bearer {{token}}

Com This session only, o valor desaparece quando fechares o Fogo e nunca toca no disco. Se quiseres que dure, escolhe um ambiente em vez disso.

Correr uma coleção

Botão direito numa coleção ou pasta → Run. Os pedidos correm por ordem e vês cada resultado à medida que chega.

Verificações

No separador Tests de cada pedido escreves o que tem de ser verdade: o estado esperado, um campo do corpo, um cabeçalho. Numa corrida, isso vira uma lista de passou ou falhou.

Uma corrida por linha de um ficheiro

Escolhe Run with data… e aponta para um CSV ou um JSON. Cada linha é uma passagem, e as colunas ficam disponíveis como variáveis. É a forma de testar quarenta casos sem criar quarenta pedidos.

Um CSV de casos

numeroProcesso,estadoEsperado
2026/0184,200
2026/9999,404
invalido,400

Três passagens, com {{numeroProcesso}} a mudar em cada uma. No fim há um relatório que podes guardar.

Guardar em git

As coleções podem viver como ficheiros no disco, num formato JSON que compara bem entre versões. Assim ficam num repositório como o resto do código do projeto.

  1. Botão direito na coleção → Save to folder
  2. Botão direito → Folder & Git…Open Git
  3. No ecrã do git: vês o que mudou, escreves a mensagem e commitas

O git trabalha sobre a pasta inteira das coleções, não sobre cada coleção à parte. Uma equipa tem um repositório e um clone, e não um por coleção.

Nenhuma credencial vai para os ficheiros. O tipo de autorização viaja, o valor não. Uma referência como {{token}} fica — porque uma referência não é um segredo. E se puseres uma palavra-passe no endereço do repositório, ela é apagada de todas as mensagens que o Fogo te mostra.

As variáveis da coleção viajam com ela, no fogo.json. Quem clonar recebe o baseUrl a funcionar; os segredos ficam por preencher, cada um com os seus.

Proxy e certificados

Nas definições, para quando a rede não é simples:

  • Proxy HTTP ou SOCKS5, com uma lista de endereços que não passam por ele
  • Certificado de cliente em formato PEM, para APIs que exigem mTLS
  • Cookies guardados entre pedidos, como um navegador faria

Os certificados da tua empresa continuam a funcionar: o Fogo valida contra o arquivo de confiança do Windows, não contra uma lista própria.

Teclado

AtalhoO que faz
Ctrl NNovo pedido
Ctrl SGuardar
Ctrl EnterEnviar (ou F5)
Ctrl WFechar separador — pergunta se houver alterações
Ctrl KProcurar
Ctrl ,Definições
EnterNa barra de endereço, envia

Onde ficam as coisas

O quêOnde
Aplicação%LOCALAPPDATA%\Fogo
Base de dados%LOCALAPPDATA%\com.fogo.api-client
Registos…\com.fogo.api-client\logs\fogo.log
ColeçõesDocumentos\Fogo Collections
SegredosGestor de Credenciais do Windows

Os dados estão de propósito fora da pasta onde a aplicação é instalada, para que desinstalar não lhes toque. Ao desinstalar, o Fogo pergunta se queres apagá-los: deixa a caixa por marcar e as coleções sobrevivem.

Nada disto sai da tua máquina. Não há conta, não há sincronização, e os registos nunca contêm tokens nem palavras-passe.

The Fogo manual

From a first request to a collection kept in git. If you read only one section, read variables — it is the part that changes how you work, and the part people arriving from Postman find most surprising.

Your first request

Open Fogo and click New Request, top right. Type an address in the bar and press Enter.

If you have a curl command to hand — copied from an API's documentation or from your browser's developer tools — paste it into the address bar. Fogo recognises it and fills in the method, headers, body and authorization at once. It is the fastest way to start.

Try it now

Paste this into the address bar and press Enter:

curl -X POST https://httpbin.org/post \
  -H "Content-Type: application/json" \
  -d '{"name":"test"}'

You get a complete POST request, header and body already filled in. httpbin.org echoes back what it received, which makes it useful for seeing exactly what went out.

The response appears below, with its status, timing and size. JSON is formatted and coloured; images and PDFs are shown in place, with nothing to save first.

Variables and layers

A variable is written {{like_this}} and saves repeating the same address or the same token in every request. It works in the address bar, in headers, in the body — in any field.

Click a variable and a small editor opens to give it a value. It is the quickest route: you do not have to go anywhere first.

The four layers

Here is the part that matters. A value can live in four places, and the lower one in this list wins:

LayerWhen it applies
GlobalsAlways, everywhere. Not selectable — it is simply always on.
CollectionIn that collection's requests, whether or not an environment is chosen.
EnvironmentIn whichever environment is selected at the top.
CapturedValues taken from a response. They last until you close Fogo.

Two APIs, one environment

The classic problem: two collections, each with its own server, and in Postman you were forever switching environments. Here you do not have to.

Collection A   baseUrl = https://a.dev   ← on the collection
Collection B   baseUrl = https://b.dev   ← on the collection
Environment Dev  token = ...            ← shared

Open a request in A  →  uses a.dev
Open a request in B  →  uses b.dev
Nothing switched.

baseUrl belongs to the collection, not to something you keep swapping. token genuinely does change with the environment — which is exactly why it lives there.

Where to write each one

  • On the collection: right-click the collection → Variables…
  • In globals: the environments panel, the Globals row above the list
  • In an environment: the environments panel, the pencil on the row

You can also do all of it from the editor that opens when you click a variable: the Save in field chooses the layer.

Secrets

Mark a variable Secret and its value moves to the Windows credential manager rather than Fogo's database. It is masked on screen and stripped from history, logs, exports and generated code. A variable marked this way never reaches a file you could commit by accident.

Authorization

In each request's Authorization tab. The types available are No Auth, Basic Auth, Bearer Token, API Key, Digest Auth and OAuth 2.0.

Set it once for a whole collection

This is almost always what you want. Right-click the collection → Collection settings… → the Authorization tab. Each request then stays on Inherit from collection — which is already the default — and uses what you put there.

The token lives in one place. When it changes, you change it once rather than in forty requests.

OAuth 2.0

Fogo handles the flows that need no browser: client credentials and password. It fetches the token itself, keeps it in memory while it is valid, and renews it on expiry. The token is never written to disk.

The authorization code flow with PKCE does not exist yet, so it is not in the list. Better absent than offered and unable to finish.

The request body

In the Body tab: None, JSON, GraphQL, Text, Form Data and x-www-form-urlencoded.

The JSON editor points out a missing brace or comma — and understands {{variables}} in the middle of it without calling them errors. Form Data lets you attach files.

For GraphQL you write the query and its variables in separate fields, and Fogo assembles the request the way the server expects.

Bringing it from Postman

The Import button. It takes Postman collections and environments, OpenAPI 3, Swagger 2 and cURL commands — and works out the format itself, without you having to say which it is.

Drag the file in, paste the contents, or drop the .zip that Postman's Export Data produces.

A collection's variables land on the collection, which is where Postman keeps them too. An imported collection works immediately, with no environment to pick first.

Before writing anything, Fogo shows what it will create and warns if any {{...}} is left undefined. An import never changes or deletes what is already there — it only adds.

Capturing values from a response

The usual case: you log in, get a token back, and want to use it in the requests that follow without copying it by hand.

In the login request's Extract tab you say where the value comes from and what name it is kept under. From then on {{token}} resolves in any request.

A login that feeds the rest

Login response   { "access_token": "eyJhbGciOi..." }

Extract          path   access_token
                 name   token
                 store  This session only

Later requests   Authorization: Bearer {{token}}

With This session only the value disappears when you close Fogo and never touches the disk. To keep it, choose an environment instead.

Running a collection

Right-click a collection or folder → Run. The requests run in order and each result appears as it arrives.

Assertions

In each request's Tests tab you write what must be true: the expected status, a field in the body, a header. In a run, that becomes a list of passes and failures.

One run per row of a file

Choose Run with data… and point it at a CSV or JSON file. Each row is one pass, and the columns are available as variables. It is how you test forty cases without creating forty requests.

A CSV of cases

caseNumber,expectedStatus
2026/0184,200
2026/9999,404
invalid,400

Three passes, with {{caseNumber}} changing each time. A report you can keep comes out at the end.

Keeping it in git

Collections can live as files on disk, in a JSON format that diffs cleanly. They then sit in a repository like the rest of the project.

  1. Right-click the collection → Save to folder
  2. Right-click → Folder & Git…Open Git
  3. In the git screen: see what changed, write a message, commit

Git works on the whole collections folder, not on each collection separately. A team has one repository and one clone rather than one per collection.

No credential goes into the files. The shape of the authorization travels, the value does not. A reference like {{token}} stays — a reference is not a credential. And if you put a password in the repository's address, it is scrubbed from every message Fogo shows you.

A collection's variables travel with it, in fogo.json. Whoever clones gets a working baseUrl; the secrets arrive empty, for each person to fill in.

Proxy and certificates

In settings, for when the network is not simple:

  • Proxy, HTTP or SOCKS5, with a list of addresses that bypass it
  • Client certificate in PEM format, for APIs that require mTLS
  • Cookies kept between requests, as a browser would

Your company's certificates keep working: Fogo validates against the Windows trust store, not against a list of its own.

Keyboard

ShortcutWhat it does
Ctrl NNew request
Ctrl SSave
Ctrl EnterSend (or F5)
Ctrl WClose tab — asks if there are unsaved changes
Ctrl KSearch
Ctrl ,Settings
EnterIn the address bar, sends

Where things live

WhatWhere
Application%LOCALAPPDATA%\Fogo
Database%LOCALAPPDATA%\com.fogo.api-client
Logs…\com.fogo.api-client\logs\fogo.log
CollectionsDocuments\Fogo Collections
SecretsWindows Credential Manager

The data sits outside the folder the application is installed into, on purpose, so uninstalling cannot touch it. Uninstalling asks whether to delete it: leave the box unticked and your collections survive.

None of this leaves your machine. There is no account, no sync, and the logs never contain tokens or passwords.