@@ -0,0 +1,17 @@
+import app from '@/app';
+import { getRegionByCode } from '@/services/ibge/gov';
+import NotFoundError from '@/errors/NotFoundError';
+
+const action = async (request, response) => {
+  const { regionCode } = request.query;
+  const { data, status } = await getRegionByCode(regionCode);
+
+  if (Array.isArray(data) && !data.length) {
+    throw new NotFoundError({ message: 'Região não encontrada.' });
+  }
+
+  response.status(status);
+  return response.json(data);
+};
+
+export default app().get(action);
@@ -0,0 +1,11 @@
+import app from '@/app';
+import { getRegions } from '@/services/ibge/gov';
+
+const action = async (_, response) => {
+  const { data, status } = await getRegions();
+
+  response.status(status);
+  return response.json(data);
+};
+
+export default app().get(action);
@@ -0,0 +1,17 @@
+import app from '@/app';
+import { getUfsByRegion } from '@/services/ibge/gov';
+import NotFoundError from '@/errors/NotFoundError';
+
+const action = async (request, response) => {
+  const { regionCode } = request.query;
+  const { data, status } = await getUfsByRegion(regionCode);
+
+  if (Array.isArray(data) && !data.length) {
+    throw new NotFoundError({ message: 'Região não encontrada.' });
+  }
+
+  response.status(status);
+  return response.json(data);
+};
+
+export default app().get(action);
@@ -504,6 +504,69 @@
                     }
                 }
             }
+        },
+        "/ibge/regioes/v1/{region}": {
+            "get": {
+                "tags": [
+                    "IBGE"
+                ],
+                "summary": "Busca as informações de uma região à partir da sigla ou código",
+                "description": "",
+                "responses": {
+                    "200": {
+                        "description": "Success",
+                        "content": {
+                            "application/json": {
+                                "schema": {
+                                    "type": "array",
+                                    "items": {
+                                        "$ref": "#/components/schemas/State"
+                                    }
+                                }
+                            }
+                        }
+                    },
+                    "404": {
+                        "description": "O código / sigla da região não foi encontrado",
+                        "content": {
+                            "application/json": {
+                                "schema": {
+                                    "$ref": "#/components/schemas/ErrorMessage"
+                                },
+                                "example": {
+                                    "name": "NotFoundError",
+                                    "message": "Região não encontrada.",
+                                    "type": "not_found"
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        },
+        "/ibge/regioes/v1": {
+            "get": {
+                "tags": [
+                    "IBGE"
+                ],
+                "summary": "Retorna as informações das regiões do Brasil",
+                "description": "",
+                "responses": {
+                    "200": {
+                        "description": "Success",
+                        "content": {
+                            "application/json": {
+                                "schema": {
+                                    "type": "array",
+                                    "items": {
+                                        "$ref": "#/components/schemas/Region"
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
         }
     },
     "components": {
@@ -585,4 +648,4 @@
             }
         }
     }
-}
+}
@@ -1,9 +1,12 @@
 import axios from 'axios';
-import mapUfToUfCode from '@/util/mapUfToUfCode.js'
+import mapUfToUfCode from '@/util/mapUfToUfCode.js';
 import InternalError from '@/errors/InternalError';
 
 const URL_UF = 'https://servicodados.ibge.gov.br/api/v1/localidades/estados';
-const URL_AGGREGATES = 'https://servicodados.ibge.gov.br/api/v3/agregados'
+
+const URL_REGION =
+  'https://servicodados.ibge.gov.br/api/v1/localidades/regioes';
+const URL_AGGREGATES = 'https://servicodados.ibge.gov.br/api/v3/agregados';
 
 const UF_CAPITAIS = {
   AC: 'Rio Branco',
@@ -68,20 +71,29 @@ export const getUfEstimatePopulationByCode = async (uf) => {
   const ESTIMATED_POPULATION_VARIABLE_ID = 9324;
   const LATEST_PERIOD = -1;
 
-  let { data } = await axios
-    .get(`${URL_AGGREGATES}/${ESTIMATED_POPULATION_AGGREGATE_ID}/periodos/${LATEST_PERIOD}/variaveis?localidades=N3[${ufCode}]`);
-  
+  let { data } = await axios.get(
+    `${URL_AGGREGATES}/${ESTIMATED_POPULATION_AGGREGATE_ID}/periodos/${LATEST_PERIOD}/variaveis?localidades=N3[${ufCode}]`
+  );
+
   data = data.find((item) => item.id == ESTIMATED_POPULATION_VARIABLE_ID);
 
-  if(!data){
+  if (!data) {
     throw new InternalError('Empty data');
   }
 
   const result = data.resultados[0].series[0].serie;
-  const key = Object.keys(result)[0]
+  const key = Object.keys(result)[0];
 
   return {
-    "populacao_estimada": parseInt(result[key]),
-    "periodo": key
-  }
-}
+    populacao_estimada: parseInt(result[key]),
+    periodo: key,
+  };
+};
+
+export const getRegions = () => axios.get(URL_REGION);
+
+export const getUfsByRegion = (regionCode) =>
+  axios.get(`${URL_REGION}/${regionCode}/estados`);
+
+export const getRegionByCode = (regionCode) =>
+  axios.get(`${URL_REGION}/${regionCode}`);
@@ -0,0 +1,92 @@
+import { describe, expect, test } from 'vitest';
+
+import axios from 'axios';
+
+// Smart service availability check (IBGE bloqueia os runners do GH Actions)
+let shouldSkipTests = false;
+
+try {
+  const response = await axios.get(
+    'https://servicodados.ibge.gov.br/api/v1/localidades/regioes',
+    { timeout: 5000 }
+  );
+  if (response.status !== 200) {
+    shouldSkipTests = true;
+  }
+} catch (error) {
+  shouldSkipTests = true;
+}
+
+describe.skipIf(shouldSkipTests)('/ibge/regioes/v1 (E2E)', () => {
+  test('Utilizando um Codigo válido: 1', async () => {
+    const requestUrl = `${global.SERVER_URL}/api/ibge/regioes/v1/1`;
+    const response = await axios.get(requestUrl);
+
+    expect(response.status).toBe(200);
+    expect(response.data).toEqual(
+      expect.objectContaining({
+        id: expect.any(Number),
+        sigla: expect.any(String),
+        nome: expect.any(String),
+      })
+    );
+  });
+
+  test('Buscando todas as regiões', async () => {
+    const requestUrl = `${global.SERVER_URL}/api/ibge/regioes/v1`;
+    const response = await axios.get(requestUrl);
+
+    expect(response.status).toBe(200);
+    expect(response.data).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          id: expect.any(Number),
+          sigla: expect.any(String),
+          nome: expect.any(String),
+        }),
+      ])
+    );
+  });
+
+  test('Utilizando um Codigo inexistente ou inválido: 99', async () => {
+    const requestUrl = `${global.SERVER_URL}/api/ibge/regioes/v1/99`;
+
+    try {
+      await axios.get(requestUrl);
+    } catch (error) {
+      const { response } = error;
+      expect(response.status).toBe(404);
+    }
+  });
+
+  test('Utilizando uma Sigla válida: S', async () => {
+    const requestUrl = `${global.SERVER_URL}/api/ibge/regioes/v1/S`;
+    const response = await axios.get(requestUrl);
+
+    expect(response.status).toBe(200);
+    expect(response.data).toEqual(
+      expect.objectContaining({
+        id: expect.any(Number),
+        sigla: expect.any(String),
+        nome: expect.any(String),
+      })
+    );
+  });
+
+  test('Utilizando um sigla inexistente ou inválida: PP', async () => {
+    const requestUrl = `${global.SERVER_URL}/api/ibge/regioes/v1/PP`;
+
+    try {
+      await axios.get(requestUrl);
+    } catch (error) {
+      const { response } = error;
+      expect(response.status).toBe(404);
+      expect(response.data).toMatchObject({
+        name: 'NotFoundError',
+        message: 'Região não encontrada.',
+        type: 'not_found',
+      });
+    }
+  });
+});
+
@@ -125,6 +125,43 @@ describeIf(shouldSkipTests)('/ibge/uf/v1 (E2E)', () => {
       });
     }
   });
+
+  test('Buscando estados por uma região válida: S', async () => {
+    const requestUrl = `${global.SERVER_URL}/api/ibge/uf/v1/regiao/S`;
+    const response = await axios.get(requestUrl);
+
+    expect(response.status).toBe(200);
+    expect(response.data).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          id: expect.any(Number),
+          sigla: expect.any(String),
+          nome: expect.any(String),
+          regiao: expect.objectContaining({
+            id: expect.any(Number),
+            sigla: expect.any(String),
+            nome: expect.any(String),
+          }),
+        }),
+      ])
+    );
+  });
+
+  test('Buscando estados por uma região inválida: 99', async () => {
+    const requestUrl = `${global.SERVER_URL}/api/ibge/uf/v1/regiao/99`;
+
+    try {
+      await axios.get(requestUrl);
+    } catch (error) {
+      const { response } = error;
+      expect(response.status).toBe(404);
+      expect(response.data).toMatchObject({
+        name: 'NotFoundError',
+        message: 'Região não encontrada.',
+        type: 'not_found',
+      });
+    }
+  });
 });
 
 // CORS tests - only run when IBGE service is healthy