Source: https://hamster-bot.com/pt/algo/grid

[← Todas as estratégias](https://hamster-bot.com/pt/algo)

# Grid

Estratégia de grade (`grid`). O bot coloca ordens limite de compra e venda em intervalos iguais dentro de uma faixa de preço definida. Quando o preço cai, o bot compra; quando sobe um passo da grade, o bot vende o que comprou. Cada par de operações "comprou em um nível → vendeu no nível vizinho acima" rende um passo da grade menos as taxas.

A grade não precisa adivinhar a direção do mercado: ela ganha com as oscilações do preço dentro da faixa, por isso funciona melhor em mercado lateral.

- A faixa do limite inferior ao superior é dividida em `grid_count` células: 20 células - 21 níveis de preço. Abaixo do preço atual ficam ordens de compra, acima - de venda, e um nível perto do preço fica vazio
- Uma compra foi executada - uma venda é colocada um nível acima. Uma venda foi executada - uma compra é colocada um nível abaixo
- Uma célula é um volume fixo que o bot compra ou vende em um nível
- O bot determina o estado da grade pelo tamanho da posição, e não por um histórico salvo de ordens. A grade sobrevive ao reinício do bot, a execuções parciais e à intervenção manual: no minuto seguinte o bot coloca as ordens que faltam e remove as excedentes. Ordens fora dos níveis da grade não são tocadas

Tipo de ordem usado: Limite (por padrão só maker). A mercado - compra inicial e stop da grade.

O gráfico do bot mostra os níveis da grade: compras, vendas, o nível vazio e os limites. Com mais de 60 níveis, só os limites são exibidos.

**⚠️ Em uma tendência forte a grade acumula posição contra o movimento (grade long na queda) ou sai da posição cedo demais (grade long na alta). Proteção contra tendência prolongada - `stop_out_percent`.**

**Como a faixa é definida - `range_type`**

| **Valor** | **Limites da grade** | **Quando usar** |
| --- | --- | --- |
| `fixed` | Definidos manualmente: `lower_price` e `upper_price` | Você sabe em qual corredor o preço se move |
| `percent` | ± `range_percent` % do preço de início | Opção universal padrão |
| `atr` | ± `atr_mult` × ATR do preço de início | A largura da grade se adapta à volatilidade atual |

**Direção - `direction`**

| **Valor** | **O que mantém** | **Como funciona** |
| --- | --- | --- |
| `long` | Long | Compra abaixo do preço, vende acima. A grade spot clássica: acumula a moeda na queda e a vende na alta |
| `short` | Short | Espelhado: vende acima do preço, recompra abaixo. Na alta acumula short |
| `neutral` | Long ou short | No preço de início não há posição. Abaixo acumula long, acima - short. Só futuros |

No mercado spot só a direção `long` está disponível.

**Passo dos níveis - `spacing`**

- `geometric` - passo igual em percentual. Para faixas largas: o lucro da célula em percentual é o mesmo em toda a grade
- `arithmetic` - passo igual em preço. Para faixas estreitas

**Trailing - `trailing`**

Uma grade long comum vende tudo em uma alta forte e para acima da faixa sem posição. Com trailing a grade se reconstrói seguindo o preço: quando o preço passa um passo acima do limite superior, o bot monta a grade de novo em torno do novo preço. Uma grade short com trailing segue o preço para baixo da mesma forma. Funciona só com `range_type` `percent` e `atr` e não se aplica a `neutral`.

**Stop da grade - `stop_out_percent` e `restart_after_stop`**

Se o preço passar do limite inferior ou superior em mais de `stop_out_percent` %, o bot cancela todas as ordens da grade e fecha a posição a mercado.

- `restart_after_stop: false` - a grade fica parada até você mudar suas configurações
- `restart_after_stop: true` - o bot monta imediatamente uma nova grade em torno do preço atual. Só para `range_type` `percent` e `atr`

**Volume e risco**

O volume de uma célula é igual ao lote normal da estratégia da seção `basic`: para `long` e `neutral` - `lot_long` ou `balance_percentage_long`, para `short` - `lot_short` ou `balance_percentage_short`. O bot calcula o volume no preço de início e não o altera até a próxima reconstrução da grade.

Posição máxima = volume da célula × número de células. Exemplo: saldo de 1 000 USDT, `balance_percentage_long: 4`, `grid_count: 20` - uma célula custa cerca de 40 USDT, a grade totalmente preenchida cerca de 800 USDT, ou seja, 80% do saldo. Leve isso em conta ao escolher o percentual e a alavancagem.

**Compra inicial - `initial_market`.** Se o preço de início estiver no meio da faixa, a grade long tem os níveis acima do preço vazios e não há o que vender lá. Com `initial_market: true` o bot compra a mercado no início tantas células quantos forem os níveis acima do preço (no exemplo acima - cerca de 10 células, ~400 USDT de uma vez). Para `short` o bot vende da mesma forma as células abaixo do preço, para `neutral` fecha a posição existente. Com `initial_market: false` o bot não compra nada no início e conta a posição já existente como células preenchidas. Sem posição, a grade long só vai comprar na queda e não vai ganhar com a alta.

**Taxas: passo mínimo**

Cada célula são duas operações, uma compra e uma venda. O lucro da célula é aproximadamente o passo da grade menos duas taxas. Se o passo for menor que duas taxas, cada operação dá prejuízo, e quanto mais a grade opera, mais perde. Exemplo: ±10% e 20 células com passo geométrico dão um passo de cerca de 1%; com taxa maker de 0.02%, 0.04% vai para taxas e a célula rende ~0.96%. Uma faixa de ±2% com as mesmas 20 células dá um passo de só 0.2%, e as taxas já levam um quinto do lucro.

Para pagar a taxa maker, mantenha `post_only: true`. Uma ordem que seria executada imediatamente a mercado é rejeitada pela exchange, e o bot a coloca de novo no minuto seguinte.

#### Parâmetros

Bloco `grid` nas configurações do bot, `basic.strategy`: `grid`

- `range_type` - como os limites são definidos: `fixed`, `percent`, `atr` (padrão `percent`)
- `lower_price`, `upper_price` - limite inferior e superior (só para `fixed`)
- `range_percent` - largura da faixa em % do preço de início para cada lado (só para `percent`, padrão 10)
- `atr_len` - período do ATR no timeframe da estratégia (só para `atr`, padrão 14)
- `atr_mult` - largura da faixa em ATR para cada lado (só para `atr`, padrão 8)
- `grid_count` - número de células (padrão 20). Quanto mais células, menor o passo e o lucro por operação e mais frequentes as operações
- `spacing` - `geometric` (passo em %) ou `arithmetic` (passo em preço), padrão `geometric`
- `direction` - `long`, `short` ou `neutral` (padrão `long`)
- `initial_market` - no início, levar a posição até a posição da grade a mercado (padrão ligado)
- `orders_per_side` - quantas ordens mais próximas do preço manter de cada lado (padrão 10); 0 - todos os níveis. Economiza margem e o limite de ordens abertas da exchange
- `post_only` - colocar ordens só como maker (padrão ligado)
- `trailing` - mover a grade seguindo o preço (só para `percent` e `atr`, padrão desligado)
- `stop_out_percent` - quantos % o preço pode passar do limite antes do stop (padrão 0 - sem stop)
- `restart_after_stop` - após o stop, montar uma nova grade a partir do preço atual (padrão desligado)

Exemplo de bloco para uma grade long de ±8% com 20 células:

```
"grid": {
  "range_type": "percent",
  "range_percent": 8,
  "grid_count": 20,
  "spacing": "geometric",
  "direction": "long",
  "initial_market": true,
  "orders_per_side": 10,
  "post_only": true,
  "trailing": false,
  "stop_out_percent": 0,
  "restart_after_stop": false
}
```

**O que é importante saber**

- **Mudar as configurações reconstrói a grade.** Se você mudar os limites, o número de células, o passo ou a direção, o bot cancela todas as ordens e monta a grade de novo a partir do preço atual. Com `initial_market: true` ele leva a posição até a nova grade a mercado
- **Um símbolo - uma grade.** Ao montar a grade, o bot cancela todas as ordens desse símbolo na conta
- **Posição contra a direção.** Se uma grade long ficar com short, ou vice-versa, a grade não opera e informa no status que a posição precisa ser fechada manualmente
- **Take-profit e stop-loss gerais** do bloco `options` devem ficar desligados (0): a grade realiza o lucro em cada nível sozinha, e `stop_out_percent` protege contra a tendência
- **Filtros de posição** (bloco `filter`) não se aplicam à grade: o lado de operação é definido por `direction`. Ainda assim o lado necessário precisa estar ligado em `basic.use_long` ou `basic.use_short`

---

Teste a estratégia com dados históricos no [testador](https://hamster-bot.com/pt/tester) e execute-a no [hamster-bot](https://hamster-bot.com/pt/download).
