Importar / Exportar

Todo lo que necesitas para migrar, respaldar o compartir tu trabajo: formatos soportados, pasos de importación/exportación y ejemplos listos para usar.

Contenido

Formatos Soportados

P

Postman Collection v2.1

Import Export

Formato nativo de Postman (JSON). Es también el formato que GetMan usa para exportar colecciones.

E

Postman Environment

Import

Archivo de entorno de Postman (_postman_variable_scope: "environment") con sus variables.

C

Cron Workflow JSON

Import Export

Workflow de cron jobs con schema_version: 1, schedule y bloques anidados.

B

Cron Folder Bundle

Import Export

Carpeta completa de cron jobs con subcarpetas y todos sus workflows anidados.

H

Documentación HTML

Export

Documentación completa exportada como HTML estático, con estilos incluidos.

M

Documentación Markdown

Export

Referencia de endpoints como Markdown (.md) para repositorios o wikis.

Importar Colección

  1. 1

    Entra a tu workspace y haz clic en "Importar Colección" en el menú lateral.

  2. 2

    Arrastra y suelta tu archivo .json o selecciónalo desde tu computadora.

  3. 3

    Revisa la vista previa (nombre, número de peticiones y carpetas).

  4. 4

    Configura las opciones de importación:

    • Importar ejemplos de respuesta: convierte las respuestas guardadas en Postman en ejemplos.
    • Importar variables de colección: conserva las variables definidas a nivel de colección.
    • Importar variables de colección como entorno: crea un entorno con las variables de la colección.
  5. 5

    Confirma la importación y la colección queda lista en tu workspace.

Pasos para exportar desde Postman

  1. 1. Abre Postman y ve a la colección que deseas exportar
  2. 2. Haz clic en los tres puntos (...) junto al nombre de la colección
  3. 3. Selecciona Export
  4. 4. Elige el formato Collection v2.1
  5. 5. Guarda el archivo JSON e impórtalo en GetMan

Al importar, GetMan convierte automáticamente:

  • Variables de colección
  • Autenticación a nivel de colección, carpeta y petición (Bearer, Basic, API Key)
  • Headers y parámetros de consulta
  • Body (raw/JSON, form-data, urlencoded, binary, GraphQL)
  • Estructura de carpetas (anidamiento ilimitado)
  • Ejemplos / respuestas guardadas (con su estado HTTP, headers y body)
  • Scripts pre-request y test (event)
  • Descripciones y documentación de cada petición

Tip: Puedes usar variables con la sintaxis {{variable}} en URLs, headers y bodies. Se reemplazarán con el valor del entorno activo, de la colección o de la variable de la petición al momento de ejecutar.

Exportar Colección

  1. 1

    Abre la colección que deseas exportar dentro de tu workspace.

  2. 2

    Usa el menú de acciones (tres puntos) y selecciona "Exportar".

  3. 3

    Se descargará un archivo JSON compatible con Postman Collection v2.1, listo para reimportar en GetMan o en Postman.

Nota: La exportación incluye la estructura de carpetas, peticiones (método, URL, headers, body y descripciones) y las variables de colección. Las respuestas mock y los ejemplos se conservan al hacer duplicado o copiar a workspace dentro de GetMan, pero no se incluyen en el archivo de exportación.

Estructura JSON de Colección

GetMan lee el formato Postman Collection v2.1. A continuación se detallan las secciones más importantes de la estructura:

Nivel raíz de la colección

{
  "info": {
    "name": "Mi API",
    "description": "Descripción de la colección",
    "schema": "https://schema.getpostman.com/json/collection/v2.1.0/collection.json"
  },
  "auth": {
    "type": "bearer",
    "bearer": [
      { "key": "token", "value": "{{token}}", "type": "string" }
    ]
  },
  "variable": [
    { "key": "base_url", "value": "https://api.ejemplo.com", "type": "string" },
    { "key": "token", "value": "mi-token-secreto", "type": "string" }
  ],
  "event": [
    {
      "listen": "test",
      "script": { "type": "text/javascript", "exec": ["tests[\"ok\"] = true;"] }
    }
  ],
  "item": [
    { "name": "Carpeta o petición", "request": { "method": "GET", "url": "..." } }
  ]
}

Estructura de una Petición (Request)

{
  "name": "Obtener usuarios",
  "request": {
    "method": "GET",
    "description": "Obtiene la lista de todos los usuarios",
    "header": [
      {
        "key": "Accept",
        "value": "application/json",
        "disabled": false
      },
      {
        "key": "Authorization",
        "value": "Bearer {{token}}",
        "disabled": false
      }
    ],
    "url": {
      "raw": "{{base_url}}/api/users?page=1&limit=10",
      "query": [
        { "key": "page", "value": "1", "description": "Número de página", "disabled": false },
        { "key": "limit", "value": "10", "description": "Cantidad por página", "disabled": false }
      ]
    },
    "body": {
      "mode": "raw",
      "raw": "{\n  \"nombre\": \"Juan\"\n}",
      "options": { "raw": { "language": "json" } }
    },
    "auth": {
      "type": "inherit"
    }
  },
  "response": [
    {
      "name": "Lista de usuarios",
      "originalRequest": { "method": "GET", "url": "{{base_url}}/api/users", "header": [] },
      "status": "OK",
      "code": 200,
      "header": [{ "key": "Content-Type", "value": "application/json" }],
      "body": "{ \"data\": [{\"id\": 1, \"name\": \"Juan\"}] }"
    }
  ]
}

url como texto o como objeto

GetMan acepta "url": "https://api.com/users" o el objeto "url": {"raw": "...", "query": [...]} con los parámetros separados.

Carpetas

Una carpeta es un elemento con "item" anidado (y sin "request"). Puede contener más carpetas y peticiones.

Tipos de Body

raw (JSON)

Body en formato JSON crudo

"body": {
  "mode": "raw",
  "raw": "{\n  \"name\": \"John Doe\",\n  \"email\": \"john@example.com\"\n}",
  "options": { "raw": { "language": "json" } }
}

form-data

Datos de formulario multipart (para archivos)

"body": {
  "mode": "formdata",
  "formdata": [
    { "key": "name", "value": "John Doe", "type": "text", "disabled": false },
    { "key": "avatar", "value": "", "type": "file", "disabled": false }
  ]
}

x-www-form-urlencoded

Datos de formulario codificados en URL

"body": {
  "mode": "urlencoded",
  "urlencoded": [
    { "key": "username", "value": "john", "disabled": false },
    { "key": "password", "value": "secret123", "disabled": false }
  ]
}

Tipos de Autenticación

Tipo auth.type (Postman) auth_data
Sin autenticación none —
Heredar del padre inherit —
Basic Auth basic [{"key": "username", "value": "user"}, {"key": "password", "value": "pass"}]
Bearer Token bearer [{"key": "token", "value": "your-token", "type": "string"}]
API Key apikey [{"key": "key", "value": "X-API-Key"}, {"key": "value", "value": "your-key"}, {"key": "in", "value": "header"}]

Métodos HTTP Soportados

GET POST PUT PATCH DELETE HEAD OPTIONS

Importar Entornos de Postman

Además de colecciones, GetMan permite importar archivos de entorno de Postman. Un entorno es cualquier archivo JSON con: 

{
  "_postman_variable_scope": "environment",
  "name": "Desarrollo",
  "values": [
    {
      "key": "base_url",
      "value": "http://localhost:8000",
      "type": "default",
      "enabled": true
    },
    {
      "key": "api_key",
      "value": "sk-secreto",
      "type": "secret",
      "enabled": true
    }
  ]
}
  1. 1

    En el workspace ve a la pestaña Environments e importa el archivo .json desde la misma pantalla de importación de colecciones.

  2. 2

    GetMan detecta automáticamente que es un entorno (por _postman_variable_scope) y crea un entorno nuevo con sus variables.

  3. 3

    Actívalo desde la sección Environments para usarlo en tus peticiones.

Tip: También puedes importar las variables de una colección como entorno marcando la casilla "Importar variables de colección como entorno" al importar la colección.

Ejemplo Completo de Colección

Archivo JSON válido para importar en GetMan (formato Postman Collection v2.1): 

{
  "info": {
    "name": "API de Usuarios",
    "description": "API REST para gestión de usuarios",
    "schema": "https://schema.getpostman.com/json/collection/v2.1.0/collection.json"
  },
  "auth": {
    "type": "bearer",
    "bearer": [
      { "key": "token", "value": "{{access_token}}", "type": "string" }
    ]
  },
  "variable": [
    { "key": "base_url", "value": "https://api.ejemplo.com/v1", "type": "string" },
    { "key": "access_token", "value": "", "type": "string" }
  ],
  "item": [
    {
      "name": "Autenticación",
      "item": [
        {
          "name": "Login",
          "request": {
            "method": "POST",
            "header": [
              { "key": "Content-Type", "value": "application/json" }
            ],
            "url": {
              "raw": "{{base_url}}/auth/login"
            },
            "body": {
              "mode": "raw",
              "raw": "{\n  \"email\": \"usuario@ejemplo.com\",\n  \"password\": \"contraseña123\"\n}",
              "options": { "raw": { "language": "json" } }
            }
          },
          "response": [
            {
              "name": "Login exitoso",
              "originalRequest": {
                "method": "POST",
                "url": "{{base_url}}/auth/login",
                "header": [],
                "body": {
                  "mode": "raw",
                  "raw": "{\n  \"email\": \"usuario@ejemplo.com\"\n}"
                }
              },
              "status": "OK",
              "code": 200,
              "header": [
                { "key": "Content-Type", "value": "application/json" }
              ],
              "body": "{ \"token\": \"eyJhbGciOi...\", \"user\": { \"id\": 1, \"name\": \"Juan\" } }"
            }
          ]
        }
      ]
    },
    {
      "name": "Usuarios",
      "item": [
        {
          "name": "Listar usuarios",
          "request": {
            "method": "GET",
            "header": [ { "key": "Accept", "value": "application/json" } ],
            "url": {
              "raw": "{{base_url}}/users?page=1&per_page=15",
              "query": [
                { "key": "page", "value": "1" },
                { "key": "per_page", "value": "15" }
              ]
            }
          }
        },
        {
          "name": "Crear usuario",
          "request": {
            "method": "POST",
            "header": [
              { "key": "Content-Type", "value": "application/json" },
              { "key": "Accept", "value": "application/json" }
            ],
            "url": { "raw": "{{base_url}}/users" },
            "body": {
              "mode": "raw",
              "raw": "{\n  \"name\": \"Juan Pérez\",\n  \"email\": \"juan@ejemplo.com\",\n  \"role\": \"user\"\n}",
              "options": { "raw": { "language": "json" } }
            }
          }
        },
        {
          "name": "Eliminar usuario",
          "request": {
            "method": "DELETE",
            "url": { "raw": "{{base_url}}/users/1" }
          }
        }
      ]
    },
    {
      "name": "Health Check",
      "request": {
        "method": "GET",
        "url": { "raw": "{{base_url}}/health" }
      }
    }
  ]
}

Tip: Usa las variables {{variable}} dentro de URLs, headers y bodies. Son reemplazadas según el entorno activo de tu workspace al ejecutar la petición.

Cron Jobs (Importar / Exportar)

Los cron jobs se exportan en un JSON propio con schema_version: 1. Puedes exportar un workflow individual desde su menú de acciones y una carpeta completa (con subcarpetas y todos sus workflows) desde el menú de la carpeta.

Workflow individual

{
  "schema_version": 1,
  "name": "Sincronizar catálogo",
  "description": "Obtiene el token y sincroniza el catálogo de productos",
  "schedule": "*/5 * * * *",
  "timezone": "UTC",
  "environment_id": null,
  "source": "wizard",
  "settings": {
    "interval_seconds": null,
    "error_limit": 5,
    "notify_email": true,
    "notify_webhook_url": null,
    "prevent_overlap": true,
    "max_runs": null
  },
  "blocks": [
    {
      "type": "http_request",
      "name": "Login",
      "is_enabled": true,
      "max_retries": 0,
      "config": {
        "mode": "inline",
        "method": "POST",
        "url": "https://api.ejemplo.com/auth/login",
        "headers": [
          { "key": "Content-Type", "value": "application/json" }
        ],
        "params": [],
        "body_type": "raw",
        "body": {
          "raw": "{\"email\":\"sistema@ejemplo.com\",\"password\":\"secreto\"}"
        },
        "auth_type": "none",
        "auth_data": [],
        "extract_variables": [
          { "key": "access_token", "source": "body", "path": "token" }
        ]
      },
      "children": [],
      "else_children": []
    },
    {
      "type": "condition",
      "name": "¿La respuesta fue 200?",
      "is_enabled": true,
      "max_retries": 0,
      "config": {
        "logic": "and",
        "rules": [
          { "source": "status_code", "operator": "equals", "value": "200" }
        ]
      },
      "children": [
        {
          "type": "http_request",
          "name": "Sync catálogo",
          "is_enabled": true,
          "max_retries": 2,
          "config": {
            "mode": "inline",
            "method": "GET",
            "url": "https://api.ejemplo.com/catalogos/sync",
            "headers": [
              { "key": "Authorization", "value": "Bearer {{access_token}}" }
            ],
            "params": [],
            "body_type": "none",
            "body": [],
            "auth_type": "none",
            "auth_data": []
          },
          "children": [],
          "else_children": []
        }
      ],
      "else_children": [
        {
          "type": "delay",
          "name": "Esperar 60s",
          "is_enabled": true,
          "max_retries": 0,
          "config": { "seconds": 60 },
          "children": [],
          "else_children": []
        }
      ]
    }
  ]
}

Tipos de bloque

  • http_request — petición inline (config.mode = "inline" con method, url, headers, body) o referencia a un request de colección (config.mode = "reference" con collection_id y request_id).
  • delay — espera N segundos (config.seconds).
  • condition — evalúa status, body o variables; ramas children (true) y else_children (false).
  • group — agrupa bloques; ejecuta sus children en orden, se detiene al primer error.

Extraer variables de respuestas

En bloques http_request usa config.extract_variables. Fuentes: body (path por puntos, ej. token o data.id), header y status_code.

Frecuencia

Intervalo mínimo de 30 segundos: combina settings.interval_seconds: 30 con el schedule * * * * *. Puedes limitar ejecuciones con settings.max_runs (null = ilimitado).

Bundle de carpeta

Al exportar una carpeta de cron jobs se genera un bundle que recrea carpetas, subcarpetas y todos los workflows. El import permite subir tanto bundles como workflows individuales (e incluso un array JSON con varios workflows). 

{
  "schema_version": 1,
  "type": "cron_folder_bundle",
  "exported_at": "2026-09-12T10:00:00Z",
  "name": "Integraciones",
  "folder": {
    "name": "Integraciones",
    "folders": [
      {
        "name": "Erp",
        "folders": [],
        "workflows": [
          {
            "schema_version": 1,
            "name": "Sync órdenes",
            "schedule": "0 */6 * * *",
            "timezone": "UTC",
            "environment_id": null,
            "source": "wizard",
            "settings": {
              "error_limit": 5,
              "notify_email": true,
              "notify_webhook_url": null,
              "prevent_overlap": true,
              "max_runs": null
            },
            "blocks": [
              {
                "type": "http_request",
                "name": "GET /ordenes",
                "is_enabled": true,
                "max_retries": 0,
                "config": {
                  "mode": "inline",
                  "method": "GET",
                  "url": "https://api.ejemplo.com/ordenes",
                  "headers": [],
                  "params": [],
                  "body_type": "none",
                  "body": [],
                  "auth_type": "none",
                  "auth_data": []
                },
                "children": [],
                "else_children": []
              }
            ]
          }
        ]
      }
    ],
    "workflows": []
  }
}

Tip: Si al importar ya existe una carpeta o workflow con el mismo nombre, GetMan agrega automáticamente un sufijo "(2)", "(3)", etc., para evitar conflictos.

Exportar Documentación

La documentación generada para una colección se puede exportar en dos formatos:

HTML estático

Un archivo autónomo con estilos incluidos. Ideal para alojarlo en cualquier servidor web, integrarlo en repositorios o distribuirlo offline.

/docs/export?format=html

Markdown

Referencia de todos los endpoints como archivo .md. Perfecto para incluir en wikis, repositorios o documentación de equipo.

/docs/export?format=markdown

Pasos para exportar

  1. 1. Abre la colección y entra al menú Configurar Documentación
  2. 2. Haz clic en el botón "Exportar" y elige HTML o Markdown
  3. 3. Se descarga el archivo correspondiente

Consejos y Solución de Problemas

"El archivo no es un JSON válido"

Verifica que el archivo esté bien formado (puedes validarlo con un linter). Si lo exportaste desde Postman, asegúrate de descargar el archivo .json y no un formato textual.

Mis variables no se resuelven

Revisa que el entorno correcto esté activo en el workspace, que la variable exista en ese entorno o en la colección, y que la escribas con la sintaxis {{variable}}.

¿Puedo importar desde Bruno?

Actualmente GetMan importa el formato JSON de Postman (Collection v2.1) y entornos de Postman. Bruno y otras herramientas suelen permitir exportar a JSON de Postman o a OpenAPI; si encuentras incompatibilidades, exporta desde la herramienta origen a formato Postman v2.1 y vuelve a intentarlo.

Backup y migración entre workspaces

Además de importar/exportar, puedes mover o copiar colecciones, mock servers, túneles, short links y cron jobs entre workspaces desde el menú de acciones de cada recurso.

¿Necesitas ayuda?

Si tienes problemas importando tu colección o el formato no es reconocido, contáctanos.

Contactar Soporte