Fala Dev, tudo em riba?

Quantas dependências tem o seu package.json agora? 30? 50? Mais de 100?

Se você trabalha com Node.js há algum tempo, provavelmente já instalou o Axios dezenas de vezes. É quase automático: criou um projeto novo, npm install axios. Precisa fazer uma requisição HTTP, Axios. Consumir uma API externa, Axios.

Mas e se eu te dissesse que, dependendo da versão do Node que você está usando, essa dependência é completamente desnecessária?

A partir da versão 18, o Node.js trouxe o Fetch API de forma nativa. E desde a versão 21, essa funcionalidade está estável e pronta para produção.

Sim, o mesmo fetch() que você já conhece do navegador agora funciona diretamente no Node, sem instalar absolutamente nada.

Por que isso importa?

Antes de entrar no código, vale entender por que trocar uma dependência que “funciona bem” por um recurso nativo faz sentido.

• Menos vulnerabilidades de segurança: Toda dependência externa é um vetor potencial de problemas. Você depende de terceiros para identificar e corrigir falhas. Com recursos nativos, a equipe do Node.js cuida disso diretamente.
• Performance otimizada: Funcionalidades que fazem parte do core do runtime são desenvolvidas com foco em eficiência. Não existe overhead de uma camada extra entre seu código e a execução.
• Menos peso no projeto: Cada dependência que você adiciona traz consigo outras dependências. Aquela pasta node_modules que pesa 500MB? Parte do problema está aí.
• Compatibilidade garantida: Quando sai uma versão nova do Node, os recursos nativos já estão prontos. Dependências externas às vezes demoram para se adaptar.

Como era antes: o jeito Axios

Vamos a um exemplo prático. Imagine que você precisa fazer duas operações comuns: buscar uma lista de usuários e criar um novo usuário.

Com Axios, o código ficaria assim:

import axios from ‘axios’;

// Buscar usuários
async function getUsers() {
  try {
    const response = await axios.get(’https://jsonplaceholder.typicode.com/users’);
    console.log(’Usuários:’, response.data);
    return response.data;
  } catch (error) {
    throw error;
  }
}

// Criar usuário
async function createUser(userData) {
  try {
    const response = await axios.post(
      ‘https://jsonplaceholder.typicode.com/users’,
      userData,
      {
        headers: { ‘Content-Type’: ‘application/json’ }
      }
    );
    console.log(’Usuário criado:’, response.data);
    return response.data;
  } catch (error) {
    throw error;
  }
}

Funciona bem, sem dúvidas. Mas exige que você tenha o Axios instalado.

Como fica agora: Fetch nativo

O mesmo código usando Fetch nativo não precisa de nenhum import externo:

// Buscar usuários
async function getUsers() {
  try {
    const response = await fetch(’https://jsonplaceholder.typicode.com/users’);
    
    if (!response.ok) {
      throw new Error(`Erro: ${response.status}`);
    }
    
    const data = await response.json();
    console.log(’Usuários:’, data);
    return data;
  } catch (error) {
    throw error;
  }
}

// Criar usuário
async function createUser(userData) {
  try {
    const response = await fetch(’https://jsonplaceholder.typicode.com/users’, {
      method: ‘POST’,
      headers: { ‘Content-Type’: ‘application/json’ },
      body: JSON.stringify(userData)
    });
    
    if (!response.ok) {
      throw new Error(`Erro: ${response.status}`);
    }
    
    const data = await response.json();
    console.log(’Usuário criado:’, data);
    return data;
  } catch (error) {
    throw error;
  }
}

Perceba que a estrutura é muito similar. Se você já usou Fetch no frontend, vai se sentir em casa.

Diferenças importantes entre Axios e Fetch

Embora parecidos, existem algumas diferenças que você precisa conhecer antes de migrar.

• Tratamento de erros. O Axios lança exceção automaticamente quando o status HTTP indica erro (4xx, 5xx). O Fetch não faz isso. Ele só lança exceção em caso de falha de rede. Por isso você precisa verificar response.ok manualmente.
• Parsing do body. No Axios, response.data já vem parseado. No Fetch, você precisa chamar response.json() explicitamente. Isso na verdade te dá mais controle, já que você pode escolher entre .json(), .text(), .blob() conforme a necessidade.
• Configuração de body. No Axios você passa o objeto diretamente. No Fetch, precisa converter para string com JSON.stringify().

Qual a performance na prática?

Em testes comparativos, o Fetch nativo tende a ser mais rápido que o Axios. Não estamos falando de diferenças absurdas na maioria dos casos, mas em aplicações que fazem muitas requisições, essa diferença se acumula.

O mais importante é que você elimina uma camada de abstração. Seu código conversa diretamente com o runtime, sem intermediários.

Quando ainda faz sentido usar Axios?

Nem tudo são flores. Existem cenários onde o Axios ainda pode fazer sentido. São eles:

• Interceptors: Se você usa interceptors para adicionar tokens de autenticação automaticamente ou tratar erros de forma global, o Axios oferece isso de forma elegante. Com Fetch, você precisaria criar uma função wrapper.
• Timeout configurável: O Axios tem timeout nativo. Com Fetch, você precisa implementar usando AbortController.
• Projetos legados: Se seu projeto já está todo estruturado com Axios e funciona bem, migrar só por migrar pode não valer o esforço.
• Funcionalidades avançadas: Cancelamento de requisições, progresso de upload, transformação automática de dados. O Axios oferece isso pronto.

Para a maioria dos casos de uso comuns, porém, o Fetch nativo resolve perfeitamente.

Como começar a migrar

Se você quer começar a usar Fetch no lugar doAxios, aqui vai um caminho seguro.

Primeiro, verifique sua versão do Node. Rode node -v no terminal. Se estiver na versão 21 ou superior, o Fetch está estável. Na versão 18 a 20, funciona mas ainda era considerado experimental.

Segundo, comece pelos casos simples. Aquela requisição GET básica que busca dados de uma API? Perfeito para testar. Não vá trocar logo de cara aquele serviço crítico que usa interceptors e retry automático.

Terceiro, teste bastante. Especialmente o tratamento de erros, que funciona diferente. Garanta que seu código está capturando falhas corretamente.

Quarto, migre gradualmente. Não precisa remover o Axios do projeto inteiro de uma vez. Vá substituindo aos poucos, validando cada mudança.

Conclusão

O Node.js está cada vez mais completo. Recursos que antes exigiam dependências externas agora vêm de “fábrica”, mais otimizados e seguros.

O Fetch nativo é um exemplo perfeito disso. Para requisições HTTP do dia a dia, você simplesmente não precisa mais do Axios.

Menos dependências significa menos vulnerabilidades, menos peso no projeto e menos dor de cabeça com atualizações.

Da próxima vez que for criar um projeto novo, antes de digitar npm install axios, pare e pense: será que eu realmente preciso disso?

Se curtiu o assunto, no vídeo abaixo eu mostro falo um pouco sobre o Fetch e outros recursos que agora são nativos no Node.js, dispensando instalação de dependências em seu projeto.👇