Laudus MCP by usefulapi

Read Laudus ERP customers, sales, purchases, stock and accounting reports; create customers.

¿Debería usar esto?

Calidad y seguridad

A
Calidad de la descripción
95%
Integridad del esquema
84%
Calidad de los nombres
79%
Riesgo de envenenamiento
100%
Coincidencia de permisos
100%
Cumplimiento del protocolo
100%

Hallazgos (1)

  • LOWTool 'laudus_customer_pending_invoices' name length outside 3-30 rangeen laudus_customer_pending_invoices

Basado en el análisis automatizado de las definiciones de herramientas y el cumplimiento del protocolo.

Costo de contexto

~12,219Tokens (definiciones de herramientas)
~2.5 KBTamaño de respuesta típico
Impacto significativo en la atención (9.55% del contexto de 128k)

Este es el número aproximado de tokens que se consumen cada vez que las herramientas del servidor se cargan en el contexto de un modelo. Los recuentos más altos reducen la atención disponible para otras tareas.

Instalar

Instalación con un clic

Agrega esto a tu archivo `claude_desktop_config.json`:

{
  "mcpServers": {
    "laudus": {
      "url": "https://laudus.usefulapi.io/mcp"
    }
  }
}

Puntos de conexión remotos

https://laudus.usefulapi.io/mcpstreamable-http

Qué puede hacer

Inventario de herramientas

Herramientas (38)

🟢 Solo lectura🟡 Escritura🔴 Eliminación⚪ Desconocido
🟢laudus_list_customers(fields, filter, order_by, limit, offset)

List customers with filters, sorting, field selection and paging (rows 25 by default, at most 200). Field names follow the Laudus data model, for example customerId, name, legalName, VATId, email, phone1, city, county, creditLimit, blocked, customerCategory.name, salesman.name. When a page is full, ask for the next one with offset = offset + limit. POST /sales/customers/list.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "fields": {
      "description": "Fields to return (default: all). Nested names work, e.g. customer.name, items.quantity.",
      "maxItems": 100,
      "type": "array",
      "items": {
        "type": "string",
        "minLength": 1,
        "maxLength": 200
      }
    },
    "filter": {
      "description": "Conditions, all of which must hold (AND).",
      "maxItems": 30,
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "field": {
            "type": "string",
            "minLength": 1,
            "maxLength": 200,
            "description": "A field of the entity, also nested (customer.name, items.product.sku)."
          },
          "operator": {
            "type": "string",
            "enum": [
              "=",
              "!=",
              ">",
              "<",
              ">=",
              "<=",
              "contains",
              "starts",
              "ends"
            ],
            "description": "\"contains\", \"starts\", \"ends\" are for text; text matching ignores case."
          },
          "value": {
            "anyOf": [
              {
                "type": [
                  "string",
                  "number",
                  "boolean"
                ]
              },
              {
                "minItems": 1,
                "maxItems": 200,
                "type": "array",
                "items": {
                  "type": [
                    "string",
                    "number",
                    "boolean"
                  ]
                }
              }
            ],
            "description": "One value, or an array (matches any of them). Dates as 2026-01-31T23:59:59."
          }
        },
        "required": [
          "field",
          "operator",
          "value"
        ]
      }
    },
    "order_by": {
      "description": "Sort order.",
      "maxItems": 10,
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "field": {
            "type": "string",
            "minLength": 1,
            "maxLength": 200
          },
          "direction": {
            "description": "Default ASC.",
            "type": "string",
            "enum": [
              "ASC",
              "DESC"
            ]
          }
        },
        "required": [
          "field"
        ]
      }
    },
    "limit": {
      "description": "Rows to return, 1-200 (default 25).",
      "type": "integer",
      "exclusiveMinimum": 0,
      "maximum": 200
    },
    "offset": {
      "description": "Rows to skip (default 0). For the next page pass offset + limit.",
      "type": "integer",
      "minimum": 0,
      "maximum": 10000000
    }
  },
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}
🟢laudus_list_sales_invoices(fields, filter, order_by, limit, offset)

List sales invoices and electronic tax documents (facturas, notas de credito) with filters, sorting, field selection and paging (rows 25 by default, at most 200). Field names follow the Laudus data model, for example salesInvoiceId, docType.name, docNumber, issuedDate, dueDate, customer.name, customer.VATId, totals.net, totals.total, items.product.sku, items.quantity. When a page is full, ask for the next one with offset = offset + limit. POST /sales/invoices/list.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "fields": {
      "description": "Fields to return (default: all). Nested names work, e.g. customer.name, items.quantity.",
      "maxItems": 100,
      "type": "array",
      "items": {
        "type": "string",
        "minLength": 1,
        "maxLength": 200
      }
    },
    "filter": {
      "description": "Conditions, all of which must hold (AND).",
      "maxItems": 30,
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "field": {
            "type": "string",
            "minLength": 1,
            "maxLength": 200,
            "description": "A field of the entity, also nested (customer.name, items.product.sku)."
          },
          "operator": {
            "type": "string",
            "enum": [
              "=",
              "!=",
              ">",
              "<",
              ">=",
              "<=",
              "contains",
              "starts",
              "ends"
            ],
            "description": "\"contains\", \"starts\", \"ends\" are for text; text matching ignores case."
          },
          "value": {
            "anyOf": [
              {
                "type": [
                  "string",
                  "number",
                  "boolean"
                ]
              },
              {
                "minItems": 1,
                "maxItems": 200,
                "type": "array",
                "items": {
                  "type": [
                    "string",
                    "number",
                    "boolean"
                  ]
                }
              }
            ],
            "description": "One value, or an array (matches any of them). Dates as 2026-01-31T23:59:59."
          }
        },
        "required": [
          "field",
          "operator",
          "value"
        ]
      }
    },
    "order_by": {
      "description": "Sort order.",
      "maxItems": 10,
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "field": {
            "type": "string",
            "minLength": 1,
            "maxLength": 200
          },
          "direction": {
            "description": "Default ASC.",
            "type": "string",
            "enum": [
              "ASC",
              "DESC"
            ]
          }
        },
        "required": [
          "field"
        ]
      }
    },
    "limit": {
      "description": "Rows to return, 1-200 (default 25).",
      "type": "integer",
      "exclusiveMinimum": 0,
      "maximum": 200
    },
    "offset": {
      "description": "Rows to skip (default 0). For the next page pass offset + limit.",
      "type": "integer",
      "minimum": 0,
      "maximum": 10000000
    }
  },
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}
🟢laudus_list_sales_orders(fields, filter, order_by, limit, offset)

List sales orders (pedidos de venta) with filters, sorting, field selection and paging (rows 25 by default, at most 200). Field names follow the Laudus data model, for example salesOrderId, issuedDate, dueDate, customer.name, items.product.sku, items.quantity. When a page is full, ask for the next one with offset = offset + limit. POST /sales/orders/list.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "fields": {
      "description": "Fields to return (default: all). Nested names work, e.g. customer.name, items.quantity.",
      "maxItems": 100,
      "type": "array",
      "items": {
        "type": "string",
        "minLength": 1,
        "maxLength": 200
      }
    },
    "filter": {
      "description": "Conditions, all of which must hold (AND).",
      "maxItems": 30,
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "field": {
            "type": "string",
            "minLength": 1,
            "maxLength": 200,
            "description": "A field of the entity, also nested (customer.name, items.product.sku)."
          },
          "operator": {
            "type": "string",
            "enum": [
              "=",
              "!=",
              ">",
              "<",
              ">=",
              "<=",
              "contains",
              "starts",
              "ends"
            ],
            "description": "\"contains\", \"starts\", \"ends\" are for text; text matching ignores case."
          },
          "value": {
            "anyOf": [
              {
                "type": [
                  "string",
                  "number",
                  "boolean"
                ]
              },
              {
                "minItems": 1,
                "maxItems": 200,
                "type": "array",
                "items": {
                  "type": [
                    "string",
                    "number",
                    "boolean"
                  ]
                }
              }
            ],
            "description": "One value, or an array (matches any of them). Dates as 2026-01-31T23:59:59."
          }
        },
        "required": [
          "field",
          "operator",
          "value"
        ]
      }
    },
    "order_by": {
      "description": "Sort order.",
      "maxItems": 10,
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "field": {
            "type": "string",
            "minLength": 1,
            "maxLength": 200
          },
          "direction": {
            "description": "Default ASC.",
            "type": "string",
            "enum": [
              "ASC",
              "DESC"
            ]
          }
        },
        "required": [
          "field"
        ]
      }
    },
    "limit": {
      "description": "Rows to return, 1-200 (default 25).",
      "type": "integer",
      "exclusiveMinimum": 0,
      "maximum": 200
    },
    "offset": {
      "description": "Rows to skip (default 0). For the next page pass offset + limit.",
      "type": "integer",
      "minimum": 0,
      "maximum": 10000000
    }
  },
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}
🟢laudus_list_sales_quotes(fields, filter, order_by, limit, offset)

List sales quotes (cotizaciones) with filters, sorting, field selection and paging (rows 25 by default, at most 200). Field names follow the Laudus data model, for example salesQuoteId, issuedDate, customer.name, items.product.sku, items.quantity. When a page is full, ask for the next one with offset = offset + limit. POST /sales/quotes/list.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "fields": {
      "description": "Fields to return (default: all). Nested names work, e.g. customer.name, items.quantity.",
      "maxItems": 100,
      "type": "array",
      "items": {
        "type": "string",
        "minLength": 1,
        "maxLength": 200
      }
    },
    "filter": {
      "description": "Conditions, all of which must hold (AND).",
      "maxItems": 30,
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "field": {
            "type": "string",
            "minLength": 1,
            "maxLength": 200,
            "description": "A field of the entity, also nested (customer.name, items.product.sku)."
          },
          "operator": {
            "type": "string",
            "enum": [
              "=",
              "!=",
              ">",
              "<",
              ">=",
              "<=",
              "contains",
              "starts",
              "ends"
            ],
            "description": "\"contains\", \"starts\", \"ends\" are for text; text matching ignores case."
          },
          "value": {
            "anyOf": [
              {
                "type": [
                  "string",
                  "number",
                  "boolean"
                ]
              },
              {
                "minItems": 1,
                "maxItems": 200,
                "type": "array",
                "items": {
                  "type": [
                    "string",
                    "number",
                    "boolean"
                  ]
                }
              }
            ],
            "description": "One value, or an array (matches any of them). Dates as 2026-01-31T23:59:59."
          }
        },
        "required": [
          "field",
          "operator",
          "value"
        ]
      }
    },
    "order_by": {
      "description": "Sort order.",
      "maxItems": 10,
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "field": {
            "type": "string",
            "minLength": 1,
            "maxLength": 200
          },
          "direction": {
            "description": "Default ASC.",
            "type": "string",
            "enum": [
              "ASC",
              "DESC"
            ]
          }
        },
        "required": [
          "field"
        ]
      }
    },
    "limit": {
      "description": "Rows to return, 1-200 (default 25).",
      "type": "integer",
      "exclusiveMinimum": 0,
      "maximum": 200
    },
    "offset": {
      "description": "Rows to skip (default 0). For the next page pass offset + limit.",
      "type": "integer",
      "minimum": 0,
      "maximum": 10000000
    }
  },
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}
🟢laudus_list_sales_receipts(fields, filter, order_by, limit, offset)

List customer payments received (cobros) with filters, sorting, field selection and paging (rows 25 by default, at most 200). Field names follow the Laudus data model, for example receiptId, receiptType, issuedDate, dueDate. When a page is full, ask for the next one with offset = offset + limit. POST /sales/receipts/list.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "fields": {
      "description": "Fields to return (default: all). Nested names work, e.g. customer.name, items.quantity.",
      "maxItems": 100,
      "type": "array",
      "items": {
        "type": "string",
        "minLength": 1,
        "maxLength": 200
      }
    },
    "filter": {
      "description": "Conditions, all of which must hold (AND).",
      "maxItems": 30,
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "field": {
            "type": "string",
            "minLength": 1,
            "maxLength": 200,
            "description": "A field of the entity, also nested (customer.name, items.product.sku)."
          },
          "operator": {
            "type": "string",
            "enum": [
              "=",
              "!=",
              ">",
              "<",
              ">=",
              "<=",
              "contains",
              "starts",
              "ends"
            ],
            "description": "\"contains\", \"starts\", \"ends\" are for text; text matching ignores case."
          },
          "value": {
            "anyOf": [
              {
                "type": [
                  "string",
                  "number",
                  "boolean"
                ]
              },
              {
                "minItems": 1,
                "maxItems": 200,
                "type": "array",
                "items": {
                  "type": [
                    "string",
                    "number",
                    "boolean"
                  ]
                }
              }
            ],
            "description": "One value, or an array (matches any of them). Dates as 2026-01-31T23:59:59."
          }
        },
        "required": [
          "field",
          "operator",
          "value"
        ]
      }
    },
    "order_by": {
      "description": "Sort order.",
      "maxItems": 10,
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "field": {
            "type": "string",
            "minLength": 1,
            "maxLength": 200
          },
          "direction": {
            "description": "Default ASC.",
            "type": "string",
            "enum": [
              "ASC",
              "DESC"
            ]
          }
        },
        "required": [
          "field"
        ]
      }
    },
    "limit": {
      "description": "Rows to return, 1-200 (default 25).",
      "type": "integer",
      "exclusiveMinimum": 0,
      "maximum": 200
    },
    "offset": {
      "description": "Rows to skip (default 0). For the next page pass offset + limit.",
      "type": "integer",
      "minimum": 0,
      "maximum": 10000000
    }
  },
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}
🟢laudus_list_products(fields, filter, order_by, limit, offset)

List products and services (the item master) with filters, sorting, field selection and paging (rows 25 by default, at most 200). Field names follow the Laudus data model, for example productId, sku, description, productCategory.name, unitOfMeasure, unitPrice, stockable, discontinued. When a page is full, ask for the next one with offset = offset + limit. POST /production/products/list.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "fields": {
      "description": "Fields to return (default: all). Nested names work, e.g. customer.name, items.quantity.",
      "maxItems": 100,
      "type": "array",
      "items": {
        "type": "string",
        "minLength": 1,
        "maxLength": 200
      }
    },
    "filter": {
      "description": "Conditions, all of which must hold (AND).",
      "maxItems": 30,
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "field": {
            "type": "string",
            "minLength": 1,
            "maxLength": 200,
            "description": "A field of the entity, also nested (customer.name, items.product.sku)."
          },
          "operator": {
            "type": "string",
            "enum": [
              "=",
              "!=",
              ">",
              "<",
              ">=",
              "<=",
              "contains",
              "starts",
              "ends"
            ],
            "description": "\"contains\", \"starts\", \"ends\" are for text; text matching ignores case."
          },
          "value": {
            "anyOf": [
              {
                "type": [
                  "string",
                  "number",
                  "boolean"
                ]
              },
              {
                "minItems": 1,
                "maxItems": 200,
                "type": "array",
                "items": {
                  "type": [
                    "string",
                    "number",
                    "boolean"
                  ]
                }
              }
            ],
            "description": "One value, or an array (matches any of them). Dates as 2026-01-31T23:59:59."
          }
        },
        "required": [
          "field",
          "operator",
          "value"
        ]
      }
    },
    "order_by": {
      "description": "Sort order.",
      "maxItems": 10,
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "field": {
            "type": "string",
            "minLength": 1,
            "maxLength": 200
          },
          "direction": {
            "description": "Default ASC.",
            "type": "string",
            "enum": [
              "ASC",
              "DESC"
            ]
          }
        },
        "required": [
          "field"
        ]
      }
    },
    "limit": {
      "description": "Rows to return, 1-200 (default 25).",
      "type": "integer",
      "exclusiveMinimum": 0,
      "maximum": 200
    },
    "offset": {
      "description": "Rows to skip (default 0). For the next page pass offset + limit.",
      "type": "integer",
      "minimum": 0,
      "maximum": 10000000
    }
  },
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}
🟢laudus_list_product_categories(fields, filter, order_by, limit, offset)

List product categories with filters, sorting, field selection and paging (rows 25 by default, at most 200). Field names follow the Laudus data model, for example productCategoryId, name, fullPath. When a page is full, ask for the next one with offset = offset + limit. POST /production/products/categories/list.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "fields": {
      "description": "Fields to return (default: all). Nested names work, e.g. customer.name, items.quantity.",
      "maxItems": 100,
      "type": "array",
      "items": {
        "type": "string",
        "minLength": 1,
        "maxLength": 200
      }
    },
    "filter": {
      "description": "Conditions, all of which must hold (AND).",
      "maxItems": 30,
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "field": {
            "type": "string",
            "minLength": 1,
            "maxLength": 200,
            "description": "A field of the entity, also nested (customer.name, items.product.sku)."
          },
          "operator": {
            "type": "string",
            "enum": [
              "=",
              "!=",
              ">",
              "<",
              ">=",
              "<=",
              "contains",
              "starts",
              "ends"
            ],
            "description": "\"contains\", \"starts\", \"ends\" are for text; text matching ignores case."
          },
          "value": {
            "anyOf": [
              {
                "type": [
                  "string",
                  "number",
                  "boolean"
                ]
              },
              {
                "minItems": 1,
                "maxItems": 200,
                "type": "array",
                "items": {
                  "type": [
                    "string",
                    "number",
                    "boolean"
                  ]
                }
              }
            ],
            "description": "One value, or an array (matches any of them). Dates as 2026-01-31T23:59:59."
          }
        },
        "required": [
          "field",
          "operator",
          "value"
        ]
      }
    },
    "order_by": {
      "description": "Sort order.",
      "maxItems": 10,
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "field": {
            "type": "string",
            "minLength": 1,
            "maxLength": 200
          },
          "direction": {
            "description": "Default ASC.",
            "type": "string",
            "enum": [
              "ASC",
              "DESC"
            ]
          }
        },
        "required": [
          "field"
        ]
      }
    },
    "limit": {
      "description": "Rows to return, 1-200 (default 25).",
      "type": "integer",
      "exclusiveMinimum": 0,
      "maximum": 200
    },
    "offset": {
      "description": "Rows to skip (default 0). For the next page pass offset + limit.",
      "type": "integer",
      "minimum": 0,
      "maximum": 10000000
    }
  },
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}
🟢laudus_list_warehouses(fields, filter, order_by, limit, offset)

List warehouses (bodegas) with filters, sorting, field selection and paging (rows 25 by default, at most 200). Field names follow the Laudus data model, for example warehouseId, name, city. When a page is full, ask for the next one with offset = offset + limit. POST /production/warehouses/list.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "fields": {
      "description": "Fields to return (default: all). Nested names work, e.g. customer.name, items.quantity.",
      "maxItems": 100,
      "type": "array",
      "items": {
        "type": "string",
        "minLength": 1,
        "maxLength": 200
      }
    },
    "filter": {
      "description": "Conditions, all of which must hold (AND).",
      "maxItems": 30,
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "field": {
            "type": "string",
            "minLength": 1,
            "maxLength": 200,
            "description": "A field of the entity, also nested (customer.name, items.product.sku)."
          },
          "operator": {
            "type": "string",
            "enum": [
              "=",
              "!=",
              ">",
              "<",
              ">=",
              "<=",
              "contains",
              "starts",
              "ends"
            ],
            "description": "\"contains\", \"starts\", \"ends\" are for text; text matching ignores case."
          },
          "value": {
            "anyOf": [
              {
                "type": [
                  "string",
                  "number",
                  "boolean"
                ]
              },
              {
                "minItems": 1,
                "maxItems": 200,
                "type": "array",
                "items": {
                  "type": [
                    "string",
                    "number",
                    "boolean"
                  ]
                }
              }
            ],
            "description": "One value, or an array (matches any of them). Dates as 2026-01-31T23:59:59."
          }
        },
        "required": [
          "field",
          "operator",
          "value"
        ]
      }
    },
    "order_by": {
      "description": "Sort order.",
      "maxItems": 10,
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "field": {
            "type": "string",
            "minLength": 1,
            "maxLength": 200
          },
          "direction": {
            "description": "Default ASC.",
            "type": "string",
            "enum": [
              "ASC",
              "DESC"
            ]
          }
        },
        "required": [
          "field"
        ]
      }
    },
    "limit": {
      "description": "Rows to return, 1-200 (default 25).",
      "type": "integer",
      "exclusiveMinimum": 0,
      "maximum": 200
    },
    "offset": {
      "description": "Rows to skip (default 0). For the next page pass offset + limit.",
      "type": "integer",
      "minimum": 0,
      "maximum": 10000000
    }
  },
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}
🟢laudus_list_salesmen(fields, filter, order_by, limit, offset)

List salespeople (vendedores) with filters, sorting, field selection and paging (rows 25 by default, at most 200). Field names follow the Laudus data model, for example salesmanId, name. When a page is full, ask for the next one with offset = offset + limit. POST /sales/salesmen/list.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "fields": {
      "description": "Fields to return (default: all). Nested names work, e.g. customer.name, items.quantity.",
      "maxItems": 100,
      "type": "array",
      "items": {
        "type": "string",
        "minLength": 1,
        "maxLength": 200
      }
    },
    "filter": {
      "description": "Conditions, all of which must hold (AND).",
      "maxItems": 30,
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "field": {
            "type": "string",
            "minLength": 1,
            "maxLength": 200,
            "description": "A field of the entity, also nested (customer.name, items.product.sku)."
          },
          "operator": {
            "type": "string",
            "enum": [
              "=",
              "!=",
              ">",
              "<",
              ">=",
              "<=",
              "contains",
              "starts",
              "ends"
            ],
            "description": "\"contains\", \"starts\", \"ends\" are for text; text matching ignores case."
          },
          "value": {
            "anyOf": [
              {
                "type": [
                  "string",
                  "number",
                  "boolean"
                ]
              },
              {
                "minItems": 1,
                "maxItems": 200,
                "type": "array",
                "items": {
                  "type": [
                    "string",
                    "number",
                    "boolean"
                  ]
                }
              }
            ],
            "description": "One value, or an array (matches any of them). Dates as 2026-01-31T23:59:59."
          }
        },
        "required": [
          "field",
          "operator",
          "value"
        ]
      }
    },
    "order_by": {
      "description": "Sort order.",
      "maxItems": 10,
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "field": {
            "type": "string",
            "minLength": 1,
            "maxLength": 200
          },
          "direction": {
            "description": "Default ASC.",
            "type": "string",
            "enum": [
              "ASC",
              "DESC"
            ]
          }
        },
        "required": [
          "field"
        ]
      }
    },
    "limit": {
      "description": "Rows to return, 1-200 (default 25).",
      "type": "integer",
      "exclusiveMinimum": 0,
      "maximum": 200
    },
    "offset": {
      "description": "Rows to skip (default 0). For the next page pass offset + limit.",
      "type": "integer",
      "minimum": 0,
      "maximum": 10000000
    }
  },
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}
🟢laudus_list_suppliers(fields, filter, order_by, limit, offset)

List suppliers (proveedores) with filters, sorting, field selection and paging (rows 25 by default, at most 200). Field names follow the Laudus data model, for example supplierId, name, legalName, VATId, email, phone, city. When a page is full, ask for the next one with offset = offset + limit. POST /purchases/suppliers/list.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "fields": {
      "description": "Fields to return (default: all). Nested names work, e.g. customer.name, items.quantity.",
      "maxItems": 100,
      "type": "array",
      "items": {
        "type": "string",
        "minLength": 1,
        "maxLength": 200
      }
    },
    "filter": {
      "description": "Conditions, all of which must hold (AND).",
      "maxItems": 30,
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "field": {
            "type": "string",
            "minLength": 1,
            "maxLength": 200,
            "description": "A field of the entity, also nested (customer.name, items.product.sku)."
          },
          "operator": {
            "type": "string",
            "enum": [
              "=",
              "!=",
              ">",
              "<",
              ">=",
              "<=",
              "contains",
              "starts",
              "ends"
            ],
            "description": "\"contains\", \"starts\", \"ends\" are for text; text matching ignores case."
          },
          "value": {
            "anyOf": [
              {
                "type": [
                  "string",
                  "number",
                  "boolean"
                ]
              },
              {
                "minItems": 1,
                "maxItems": 200,
                "type": "array",
                "items": {
                  "type": [
                    "string",
                    "number",
                    "boolean"
                  ]
                }
              }
            ],
            "description": "One value, or an array (matches any of them). Dates as 2026-01-31T23:59:59."
          }
        },
        "required": [
          "field",
          "operator",
          "value"
        ]
      }
    },
    "order_by": {
      "description": "Sort order.",
      "maxItems": 10,
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "field": {
            "type": "string",
            "minLength": 1,
            "maxLength": 200
          },
          "direction": {
            "description": "Default ASC.",
            "type": "string",
            "enum": [
              "ASC",
              "DESC"
            ]
          }
        },
        "required": [
          "field"
        ]
      }
    },
    "limit": {
      "description": "Rows to return, 1-200 (default 25).",
      "type": "integer",
      "exclusiveMinimum": 0,
      "maximum": 200
    },
    "offset": {
      "description": "Rows to skip (default 0). For the next page pass offset + limit.",
      "type": "integer",
      "minimum": 0,
      "maximum": 10000000
    }
  },
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}
🟢laudus_list_purchase_invoices(fields, filter, order_by, limit, offset)

List purchase invoices (facturas de compra) with filters, sorting, field selection and paging (rows 25 by default, at most 200). Field names follow the Laudus data model, for example purchaseInvoiceId, docNumber, issuedDate, dueDate, supplier.name, totals.total. When a page is full, ask for the next one with offset = offset + limit. POST /purchases/invoices/list.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "fields": {
      "description": "Fields to return (default: all). Nested names work, e.g. customer.name, items.quantity.",
      "maxItems": 100,
      "type": "array",
      "items": {
        "type": "string",
        "minLength": 1,
        "maxLength": 200
      }
    },
    "filter": {
      "description": "Conditions, all of which must hold (AND).",
      "maxItems": 30,
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "field": {
            "type": "string",
            "minLength": 1,
            "maxLength": 200,
            "description": "A field of the entity, also nested (customer.name, items.product.sku)."
          },
          "operator": {
            "type": "string",
            "enum": [
              "=",
              "!=",
              ">",
              "<",
              ">=",
              "<=",
              "contains",
              "starts",
              "ends"
            ],
            "description": "\"contains\", \"starts\", \"ends\" are for text; text matching ignores case."
          },
          "value": {
            "anyOf": [
              {
                "type": [
                  "string",
                  "number",
                  "boolean"
                ]
              },
              {
                "minItems": 1,
                "maxItems": 200,
                "type": "array",
                "items": {
                  "type": [
                    "string",
                    "number",
                    "boolean"
                  ]
                }
              }
            ],
            "description": "One value, or an array (matches any of them). Dates as 2026-01-31T23:59:59."
          }
        },
        "required": [
          "field",
          "operator",
          "value"
        ]
      }
    },
    "order_by": {
      "description": "Sort order.",
      "maxItems": 10,
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "field": {
            "type": "string",
            "minLength": 1,
            "maxLength": 200
          },
          "direction": {
            "description": "Default ASC.",
            "type": "string",
            "enum": [
              "ASC",
              "DESC"
            ]
          }
        },
        "required": [
          "field"
        ]
      }
    },
    "limit": {
      "description": "Rows to return, 1-200 (default 25).",
      "type": "integer",
      "exclusiveMinimum": 0,
      "maximum": 200
    },
    "offset": {
      "description": "Rows to skip (default 0). For the next page pass offset + limit.",
      "type": "integer",
      "minimum": 0,
      "maximum": 10000000
    }
  },
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}
🟢laudus_list_purchase_orders(fields, filter, order_by, limit, offset)

List purchase orders (ordenes de compra) with filters, sorting, field selection and paging (rows 25 by default, at most 200). Field names follow the Laudus data model, for example purchaseOrderId, issuedDate, supplier.name, status, items.product.sku, items.quantity. When a page is full, ask for the next one with offset = offset + limit. POST /purchases/orders/list.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "fields": {
      "description": "Fields to return (default: all). Nested names work, e.g. customer.name, items.quantity.",
      "maxItems": 100,
      "type": "array",
      "items": {
        "type": "string",
        "minLength": 1,
        "maxLength": 200
      }
    },
    "filter": {
      "description": "Conditions, all of which must hold (AND).",
      "maxItems": 30,
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "field": {
            "type": "string",
            "minLength": 1,
            "maxLength": 200,
            "description": "A field of the entity, also nested (customer.name, items.product.sku)."
          },
          "operator": {
            "type": "string",
            "enum": [
              "=",
              "!=",
              ">",
              "<",
              ">=",
              "<=",
              "contains",
              "starts",
              "ends"
            ],
            "description": "\"contains\", \"starts\", \"ends\" are for text; text matching ignores case."
          },
          "value": {
            "anyOf": [
              {
                "type": [
                  "string",
                  "number",
                  "boolean"
                ]
              },
              {
                "minItems": 1,
                "maxItems": 200,
                "type": "array",
                "items": {
                  "type": [
                    "string",
                    "number",
                    "boolean"
                  ]
                }
              }
            ],
            "description": "One value, or an array (matches any of them). Dates as 2026-01-31T23:59:59."
          }
        },
        "required": [
          "field",
          "operator",
          "value"
        ]
      }
    },
    "order_by": {
      "description": "Sort order.",
      "maxItems": 10,
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "field": {
            "type": "string",
            "minLength": 1,
            "maxLength": 200
          },
          "direction": {
            "description": "Default ASC.",
            "type": "string",
            "enum": [
              "ASC",
              "DESC"
            ]
          }
        },
        "required": [
          "field"
        ]
      }
    },
    "limit": {
      "description": "Rows to return, 1-200 (default 25).",
      "type": "integer",
      "exclusiveMinimum": 0,
      "maximum": 200
    },
    "offset": {
      "description": "Rows to skip (default 0). For the next page pass offset + limit.",
      "type": "integer",
      "minimum": 0,
      "maximum": 10000000
    }
  },
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}
🟢laudus_list_accounts(fields, filter, order_by, limit, offset)

List the chart of accounts (plan de cuentas) with filters, sorting, field selection and paging (rows 25 by default, at most 200). Field names follow the Laudus data model, for example accountId, accountNumber, name. When a page is full, ask for the next one with offset = offset + limit. POST /accounting/accounts/list.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "fields": {
      "description": "Fields to return (default: all). Nested names work, e.g. customer.name, items.quantity.",
      "maxItems": 100,
      "type": "array",
      "items": {
        "type": "string",
        "minLength": 1,
        "maxLength": 200
      }
    },
    "filter": {
      "description": "Conditions, all of which must hold (AND).",
      "maxItems": 30,
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "field": {
            "type": "string",
            "minLength": 1,
            "maxLength": 200,
            "description": "A field of the entity, also nested (customer.name, items.product.sku)."
          },
          "operator": {
            "type": "string",
            "enum": [
              "=",
              "!=",
              ">",
              "<",
              ">=",
              "<=",
              "contains",
              "starts",
              "ends"
            ],
            "description": "\"contains\", \"starts\", \"ends\" are for text; text matching ignores case."
          },
          "value": {
            "anyOf": [
              {
                "type": [
                  "string",
                  "number",
                  "boolean"
                ]
              },
              {
                "minItems": 1,
                "maxItems": 200,
                "type": "array",
                "items": {
                  "type": [
                    "string",
                    "number",
                    "boolean"
                  ]
                }
              }
            ],
            "description": "One value, or an array (matches any of them). Dates as 2026-01-31T23:59:59."
          }
        },
        "required": [
          "field",
          "operator",
          "value"
        ]
      }
    },
    "order_by": {
      "description": "Sort order.",
      "maxItems": 10,
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "field": {
            "type": "string",
            "minLength": 1,
            "maxLength": 200
          },
          "direction": {
            "description": "Default ASC.",
            "type": "string",
            "enum": [
              "ASC",
              "DESC"
            ]
          }
        },
        "required": [
          "field"
        ]
      }
    },
    "limit": {
      "description": "Rows to return, 1-200 (default 25).",
      "type": "integer",
      "exclusiveMinimum": 0,
      "maximum": 200
    },
    "offset": {
      "description": "Rows to skip (default 0). For the next page pass offset + limit.",
      "type": "integer",
      "minimum": 0,
      "maximum": 10000000
    }
  },
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}
🟢laudus_list_journal_entries(fields, filter, order_by, limit, offset)

List accounting journal entries (comprobantes) with filters, sorting, field selection and paging (rows 25 by default, at most 200). Field names follow the Laudus data model, for example journalEntryId, journalEntryNumber, date, lines.account.accountNumber, lines.debit, lines.credit. When a page is full, ask for the next one with offset = offset + limit. POST /accounting/journal/entries/list.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "fields": {
      "description": "Fields to return (default: all). Nested names work, e.g. customer.name, items.quantity.",
      "maxItems": 100,
      "type": "array",
      "items": {
        "type": "string",
        "minLength": 1,
        "maxLength": 200
      }
    },
    "filter": {
      "description": "Conditions, all of which must hold (AND).",
      "maxItems": 30,
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "field": {
            "type": "string",
            "minLength": 1,
            "maxLength": 200,
            "description": "A field of the entity, also nested (customer.name, items.product.sku)."
          },
          "operator": {
            "type": "string",
            "enum": [
              "=",
              "!=",
              ">",
              "<",
              ">=",
              "<=",
              "contains",
              "starts",
              "ends"
            ],
            "description": "\"contains\", \"starts\", \"ends\" are for text; text matching ignores case."
          },
          "value": {
            "anyOf": [
              {
                "type": [
                  "string",
                  "number",
                  "boolean"
                ]
              },
              {
                "minItems": 1,
                "maxItems": 200,
                "type": "array",
                "items": {
                  "type": [
                    "string",
                    "number",
                    "boolean"
                  ]
                }
              }
            ],
            "description": "One value, or an array (matches any of them). Dates as 2026-01-31T23:59:59."
          }
        },
        "required": [
          "field",
          "operator",
          "value"
        ]
      }
    },
    "order_by": {
      "description": "Sort order.",
      "maxItems": 10,
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "field": {
            "type": "string",
            "minLength": 1,
            "maxLength": 200
          },
          "direction": {
            "description": "Default ASC.",
            "type": "string",
            "enum": [
              "ASC",
              "DESC"
            ]
          }
        },
        "required": [
          "field"
        ]
      }
    },
    "limit": {
      "description": "Rows to return, 1-200 (default 25).",
      "type": "integer",
      "exclusiveMinimum": 0,
      "maximum": 200
    },
    "offset": {
      "description": "Rows to skip (default 0). For the next page pass offset + limit.",
      "type": "integer",
      "minimum": 0,
      "maximum": 10000000
    }
  },
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}
🟢laudus_list_cost_centers(fields, filter, order_by, limit, offset)

List cost centers (centros de costo) with filters, sorting, field selection and paging (rows 25 by default, at most 200). Field names follow the Laudus data model, for example costCenterId, name, code. When a page is full, ask for the next one with offset = offset + limit. POST /purchases/costcenters/list.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "fields": {
      "description": "Fields to return (default: all). Nested names work, e.g. customer.name, items.quantity.",
      "maxItems": 100,
      "type": "array",
      "items": {
        "type": "string",
        "minLength": 1,
        "maxLength": 200
      }
    },
    "filter": {
      "description": "Conditions, all of which must hold (AND).",
      "maxItems": 30,
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "field": {
            "type": "string",
            "minLength": 1,
            "maxLength": 200,
            "description": "A field of the entity, also nested (customer.name, items.product.sku)."
          },
          "operator": {
            "type": "string",
            "enum": [
              "=",
              "!=",
              ">",
              "<",
              ">=",
              "<=",
              "contains",
              "starts",
              "ends"
            ],
            "description": "\"contains\", \"starts\", \"ends\" are for text; text matching ignores case."
          },
          "value": {
            "anyOf": [
              {
                "type": [
                  "string",
                  "number",
                  "boolean"
                ]
              },
              {
                "minItems": 1,
                "maxItems": 200,
                "type": "array",
                "items": {
                  "type": [
                    "string",
                    "number",
                    "boolean"
                  ]
                }
              }
            ],
            "description": "One value, or an array (matches any of them). Dates as 2026-01-31T23:59:59."
          }
        },
        "required": [
          "field",
          "operator",
          "value"
        ]
      }
    },
    "order_by": {
      "description": "Sort order.",
      "maxItems": 10,
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "field": {
            "type": "string",
            "minLength": 1,
            "maxLength": 200
          },
          "direction": {
            "description": "Default ASC.",
            "type": "string",
            "enum": [
              "ASC",
              "DESC"
            ]
          }
        },
        "required": [
          "field"
        ]
      }
    },
    "limit": {
      "description": "Rows to return, 1-200 (default 25).",
      "type": "integer",
      "exclusiveMinimum": 0,
      "maximum": 200
    },
    "offset": {
      "description": "Rows to skip (default 0). For the next page pass offset + limit.",
      "type": "integer",
      "minimum": 0,
      "maximum": 10000000
    }
  },
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}
🟢laudus_get_customer(customer_id)

Get a customer (addresses, contact data, credit limit, category, salesman, price list) by id. GET /sales/customers/{id}.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "customer_id": {
      "type": "integer",
      "exclusiveMinimum": 0,
      "maximum": 9007199254740991
    }
  },
  "required": [
    "customer_id"
  ],
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}
🟢laudus_get_sales_invoice(sales_invoice_id)

Get a sales invoice with its lines, taxes and totals by id. GET /sales/invoices/{id}.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "sales_invoice_id": {
      "anyOf": [
        {
          "type": "integer",
          "exclusiveMinimum": 0,
          "maximum": 9007199254740991
        },
        {
          "type": "string",
          "minLength": 1,
          "maxLength": 100
        }
      ]
    }
  },
  "required": [
    "sales_invoice_id"
  ],
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}
🟢laudus_get_sales_order(sales_order_id)

Get a sales order with its lines by id. GET /sales/orders/{id}.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "sales_order_id": {
      "type": "integer",
      "exclusiveMinimum": 0,
      "maximum": 9007199254740991
    }
  },
  "required": [
    "sales_order_id"
  ],
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}
🟢laudus_get_sales_quote(sales_quote_id)

Get a sales quote with its lines by id. GET /sales/quotes/{id}.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "sales_quote_id": {
      "type": "integer",
      "exclusiveMinimum": 0,
      "maximum": 9007199254740991
    }
  },
  "required": [
    "sales_quote_id"
  ],
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}
🟢laudus_get_product(product_id)

Get a product (SKU, description, category, units, prices) by id. GET /production/products/{id}.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "product_id": {
      "type": "integer",
      "exclusiveMinimum": 0,
      "maximum": 9007199254740991
    }
  },
  "required": [
    "product_id"
  ],
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}
🟢laudus_get_supplier(supplier_id)

Get a supplier by id. GET /purchases/suppliers/{id}.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "supplier_id": {
      "type": "integer",
      "exclusiveMinimum": 0,
      "maximum": 9007199254740991
    }
  },
  "required": [
    "supplier_id"
  ],
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}
🟢laudus_get_purchase_invoice(purchase_invoice_id)

Get a purchase invoice with its lines by id. GET /purchases/invoices/{id}.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "purchase_invoice_id": {
      "type": "integer",
      "exclusiveMinimum": 0,
      "maximum": 9007199254740991
    }
  },
  "required": [
    "purchase_invoice_id"
  ],
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}
🟢laudus_get_purchase_order(purchase_order_id)

Get a purchase order with its lines by id. GET /purchases/orders/{id}.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "purchase_order_id": {
      "type": "integer",
      "exclusiveMinimum": 0,
      "maximum": 9007199254740991
    }
  },
  "required": [
    "purchase_order_id"
  ],
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}
🟢laudus_get_journal_entry(journal_entry_id)

Get an accounting journal entry (comprobante) with its lines by id. GET /accounting/journal/entries/{id}.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "journal_entry_id": {
      "type": "integer",
      "exclusiveMinimum": 0,
      "maximum": 9007199254740991
    }
  },
  "required": [
    "journal_entry_id"
  ],
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}
🟢laudus_customer_pending_invoices(customer_id)

Unpaid sales invoices (accounts receivable). Give customer_id for one customer, or leave it out for all customers. GET /sales/customers/{id}/pendingInvoices or /sales/customers/pendingInvoices.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "customer_id": {
      "description": "Customer id; omit for every customer.",
      "type": "integer",
      "exclusiveMinimum": 0,
      "maximum": 9007199254740991
    }
  },
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}
🟢laudus_customer_credit_limit(customer_id)

A customer's credit limit and how much of it is used. GET /sales/customers/{id}/creditLimit.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "customer_id": {
      "type": "integer",
      "exclusiveMinimum": 0,
      "maximum": 9007199254740991
    }
  },
  "required": [
    "customer_id"
  ],
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}
🟢laudus_list_customer_contacts(customer_id)

The contact people of a customer. GET /sales/customers/{id}/contacts.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "customer_id": {
      "type": "integer",
      "exclusiveMinimum": 0,
      "maximum": 9007199254740991
    }
  },
  "required": [
    "customer_id"
  ],
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}
🟢laudus_sales_invoice_receipts(sales_invoice_id)

The customer payments (cobros) applied to one sales invoice. GET /sales/invoices/{id}/receipts.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "sales_invoice_id": {
      "anyOf": [
        {
          "type": "integer",
          "exclusiveMinimum": 0,
          "maximum": 9007199254740991
        },
        {
          "type": "string",
          "minLength": 1,
          "maxLength": 100
        }
      ]
    }
  },
  "required": [
    "sales_invoice_id"
  ],
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}
🟢laudus_pending_sales_orders(customer_id, due_date_from, due_date_to)

The ids of sales orders not yet delivered, optionally for one customer or a due-date range. GET /sales/orders/pending.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "customer_id": {
      "type": "integer",
      "exclusiveMinimum": 0,
      "maximum": 9007199254740991
    },
    "due_date_from": {
      "description": "Due date from (yyyy-mm-dd).",
      "type": "string",
      "pattern": "^\\d{4}-\\d{2}-\\d{2}(T\\d{2}:\\d{2}(:\\d{2})?)?$"
    },
    "due_date_to": {
      "description": "Due date to (yyyy-mm-dd).",
      "type": "string",
      "pattern": "^\\d{4}-\\d{2}-\\d{2}(T\\d{2}:\\d{2}(:\\d{2})?)?$"
    }
  },
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}
🟢laudus_sales_report(group_by, date_from, date_to, customer_id, salesman_id, ...)

Invoiced sales totals grouped by day of week, day of month, month, year, salesman, customer, customer category, product, product category, county, state or branch, for a date range and optional filters. GET /reports/sales/invoices/{group}.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "group_by": {
      "type": "string",
      "enum": [
        "byDayOfWeek",
        "byDayOfMonth",
        "byMonth",
        "byYear",
        "bySalesman",
        "byCustomer",
        "byCustomerCategory",
        "byProduct",
        "byProductCategory",
        "byCounty",
        "byState",
        "byBranch"
      ],
      "description": "How to group the totals."
    },
    "date_from": {
      "type": "string",
      "pattern": "^\\d{4}-\\d{2}-\\d{2}(T\\d{2}:\\d{2}(:\\d{2})?)?$"
    },
    "date_to": {
      "type": "string",
      "pattern": "^\\d{4}-\\d{2}-\\d{2}(T\\d{2}:\\d{2}(:\\d{2})?)?$"
    },
    "customer_id": {
      "type": "integer",
      "exclusiveMinimum": 0,
      "maximum": 9007199254740991
    },
    "salesman_id": {
      "type": "integer",
      "exclusiveMinimum": 0,
      "maximum": 9007199254740991
    },
    "product_id": {
      "type": "integer",
      "exclusiveMinimum": 0,
      "maximum": 9007199254740991
    },
    "branch_id": {
      "type": "integer",
      "exclusiveMinimum": 0,
      "maximum": 9007199254740991
    }
  },
  "required": [
    "group_by"
  ],
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}
🟢laudus_get_product_stock(product_id, date_to, warehouse_id, lot, by_warehouse)

Stock of one product, optionally as of a date, in one warehouse or lot; with by_warehouse true, the stock in each warehouse. GET /production/products/{id}/stock or /stockByWarehouses.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "product_id": {
      "type": "integer",
      "exclusiveMinimum": 0,
      "maximum": 9007199254740991
    },
    "date_to": {
      "description": "Stock as of this date (default today).",
      "type": "string",
      "pattern": "^\\d{4}-\\d{2}-\\d{2}(T\\d{2}:\\d{2}(:\\d{2})?)?$"
    },
    "warehouse_id": {
      "description": "Only this warehouse (ignored with by_warehouse).",
      "type": "string",
      "minLength": 1,
      "maxLength": 50
    },
    "lot": {
      "description": "Only this lot (ignored with by_warehouse).",
      "type": "string",
      "minLength": 1,
      "maxLength": 100
    },
    "by_warehouse": {
      "description": "Break the stock down per warehouse.",
      "type": "boolean"
    }
  },
  "required": [
    "product_id"
  ],
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}
🟢laudus_list_stock(date_to, warehouse_id, product_category_id)

Stock of every product, optionally as of a date, for one warehouse or one product category. Can be large: filter by warehouse or category. GET /production/products/stock.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "date_to": {
      "description": "Stock as of this date (default today).",
      "type": "string",
      "pattern": "^\\d{4}-\\d{2}-\\d{2}(T\\d{2}:\\d{2}(:\\d{2})?)?$"
    },
    "warehouse_id": {
      "type": "string",
      "minLength": 1,
      "maxLength": 50
    },
    "product_category_id": {
      "type": "string",
      "minLength": 1,
      "maxLength": 50
    }
  },
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}
🟢laudus_product_kardex(product_id, date_to, warehouse_id)

The stock movements (kardex) of one product, optionally to a date and for one warehouse. GET /production/products/{id}/kardex.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "product_id": {
      "type": "integer",
      "exclusiveMinimum": 0,
      "maximum": 9007199254740991
    },
    "date_to": {
      "type": "string",
      "pattern": "^\\d{4}-\\d{2}-\\d{2}(T\\d{2}:\\d{2}(:\\d{2})?)?$"
    },
    "warehouse_id": {
      "type": "string",
      "minLength": 1,
      "maxLength": 50
    }
  },
  "required": [
    "product_id"
  ],
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}
🟢laudus_balance_sheet(layout, date_to, show_accounts_with_zero_balance, show_only_accounts_with_activity, show_levels, ...)

The balance sheet (balance general) as of a date, either the standard layout or the totals layout. GET /accounting/balanceSheet/standard or /totals.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "layout": {
      "description": "Default standard.",
      "type": "string",
      "enum": [
        "standard",
        "totals"
      ]
    },
    "date_to": {
      "description": "As of this date (default today).",
      "type": "string",
      "pattern": "^\\d{4}-\\d{2}-\\d{2}(T\\d{2}:\\d{2}(:\\d{2})?)?$"
    },
    "show_accounts_with_zero_balance": {
      "type": "boolean"
    },
    "show_only_accounts_with_activity": {
      "type": "boolean"
    },
    "show_levels": {
      "description": "Account levels to show, as in Laudus (for example 1,2,3).",
      "type": "string",
      "minLength": 1,
      "maxLength": 20
    },
    "cost_center_id": {
      "type": "string",
      "minLength": 1,
      "maxLength": 50
    },
    "book_id": {
      "description": "Accounting book id (default: the main book).",
      "type": "string",
      "minLength": 1,
      "maxLength": 50
    }
  },
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}
🟢laudus_profit_and_loss(date_from, date_to, show_accounts_with_zero_balance, show_only_accounts_with_activity, show_levels, ...)

The profit and loss statement (estado de resultados) for a date range. GET /accounting/profitAndLoss.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "date_from": {
      "type": "string",
      "pattern": "^\\d{4}-\\d{2}-\\d{2}(T\\d{2}:\\d{2}(:\\d{2})?)?$"
    },
    "date_to": {
      "type": "string",
      "pattern": "^\\d{4}-\\d{2}-\\d{2}(T\\d{2}:\\d{2}(:\\d{2})?)?$"
    },
    "show_accounts_with_zero_balance": {
      "type": "boolean"
    },
    "show_only_accounts_with_activity": {
      "type": "boolean"
    },
    "show_levels": {
      "description": "Account levels to show, as in Laudus (for example 1,2,3).",
      "type": "string",
      "minLength": 1,
      "maxLength": 20
    },
    "cost_center_id": {
      "type": "string",
      "minLength": 1,
      "maxLength": 50
    },
    "book_id": {
      "description": "Accounting book id (default: the main book).",
      "type": "string",
      "minLength": 1,
      "maxLength": 50
    }
  },
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}
🟢laudus_general_ledger(account_number_from, account_number_to, date_from, date_to, cost_center_id, ...)

The general ledger (libro mayor) movements of an account or a range of account numbers, for a date range. GET /accounting/ledger.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "account_number_from": {
      "type": "string",
      "minLength": 1,
      "maxLength": 50,
      "description": "First account number (or the only one)."
    },
    "account_number_to": {
      "description": "Last account number of a range.",
      "type": "string",
      "minLength": 1,
      "maxLength": 50
    },
    "date_from": {
      "type": "string",
      "pattern": "^\\d{4}-\\d{2}-\\d{2}(T\\d{2}:\\d{2}(:\\d{2})?)?$"
    },
    "date_to": {
      "type": "string",
      "pattern": "^\\d{4}-\\d{2}-\\d{2}(T\\d{2}:\\d{2}(:\\d{2})?)?$"
    },
    "cost_center_id": {
      "type": "string",
      "minLength": 1,
      "maxLength": 50
    },
    "book_id": {
      "type": "string",
      "minLength": 1,
      "maxLength": 50
    },
    "limit": {
      "description": "Rows to return (default 100, at most 1000).",
      "type": "integer",
      "exclusiveMinimum": 0,
      "maximum": 1000
    },
    "offset": {
      "description": "Rows to skip.",
      "type": "integer",
      "minimum": 0,
      "maximum": 10000000
    }
  },
  "required": [
    "account_number_from"
  ],
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}
🟢laudus_purchase_ledger(year, month)

The purchases ledger (libro de compras) for a year and month. GET /purchases/invoices/ledger.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "year": {
      "type": "integer",
      "minimum": 1990,
      "maximum": 2100
    },
    "month": {
      "type": "integer",
      "minimum": 1,
      "maximum": 12
    }
  },
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}
🟡laudus_create_customer(name, legal_name, vat_id, activity_name, address, ...)

WRITE: creates a new customer in Laudus (the customer id is assigned by Laudus; the customer record is not an invoice and sends nothing). Check laudus_list_customers for the RUT first to avoid duplicates. Laudus may require more fields than given and answers with its validation message. POST /sales/customers.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "name": {
      "type": "string",
      "minLength": 1,
      "maxLength": 50,
      "description": "Trade name (max 50 characters)."
    },
    "legal_name": {
      "description": "Legal name / razon social (max 80).",
      "type": "string",
      "minLength": 1,
      "maxLength": 80
    },
    "vat_id": {
      "description": "Customer RUT, e.g. 76123456-7.",
      "type": "string",
      "minLength": 1,
      "maxLength": 15
    },
    "activity_name": {
      "description": "Business activity (giro).",
      "type": "string",
      "minLength": 1,
      "maxLength": 60
    },
    "address": {
      "type": "string",
      "minLength": 1,
      "maxLength": 80
    },
    "city": {
      "type": "string",
      "minLength": 1,
      "maxLength": 30
    },
    "county": {
      "description": "Comuna.",
      "type": "string",
      "minLength": 1,
      "maxLength": 20
    },
    "email": {
      "type": "string",
      "minLength": 1,
      "maxLength": 60
    },
    "dte_email": {
      "description": "Email for electronic tax documents.",
      "type": "string",
      "minLength": 1,
      "maxLength": 60
    },
    "phone": {
      "type": "string",
      "minLength": 1,
      "maxLength": 15
    },
    "notes": {
      "type": "string",
      "minLength": 1,
      "maxLength": 2000
    }
  },
  "required": [
    "name"
  ],
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}

Comunidad

Califica este servidor

Evidencia

Observaciones recientes

verificadoversión no registrada38 herramientas