+++ title = “Chameleoon MCP Server” linkbuilding = [ “shipping mcp”, “mcp server available tool”, “mcp server provides tools”, “tools mcp server”, “mcp server tools” ] keywords = [ “chameleoon mcp server”, “shipping management mcp”, “mcp server”, “shipping automation”, “parcel tracking”, “logistics mcp”, “model context protocol” ] description = “Automatice las operaciones de envío y la gestión de entrega de paquetes con IA utilizando el servidor Chameleoon MCP. Integre con múltiples transportistas, rastree envíos, genere etiquetas y administre recolecciones a través de comandos en lenguaje natural en herramientas como Claude, Cursor, Windsurf y FlowHunt.” image = “/images/hosted-mcp-servers/biznisweb.webp” shortDescription = “Optimice las operaciones de envío y los flujos de trabajo logísticos con automatización impulsada por IA. El servidor Chameleoon MCP conecta su asistente de IA con la gestión de envíos multi-transportista, seguimiento de paquetes, generación de etiquetas y programación de recolecciones.” tags = [ “Shipping”, “Logistics”, “E-commerce”, “MCP”, “AI Integration”, “Automation” ] categories = [ “Integrations”, “MCP Servers” ] showCTA = true ctaHeading = “Pruebe el servidor Chameleoon MCP con FlowHunt” ctaDescription = “Transforme sus flujos de trabajo de envío con automatización IA. Gestione pedidos entre múltiples transportistas, rastree entregas y optimice las operaciones logísticas directamente desde sus herramientas favoritas.” ctaPrimaryText = “Pruébalo ahora” ctaPrimaryURL = “https://app.flowhunt.io/sign-in" ctaSecondaryText = “Reservar una demo” ctaSecondaryURL = “/demo/” fork = 0 star = 0 overallScore = "” date = “2026-01-14 13:44:27”

[[mcpServerConf]] client = “windsurf” config = “1. Obtain your Chameleoon API key from chameleoon.sk 2. Add the Chameleoon MCP server to your mcpServers config: { "mcpServers": { "chameleoon": { "command": "python3", "args": ["-m", "chameleoon_mcp_server"], "env": { "CHAMELEOON_API_KEY": "your_api_key_here" } } } } 3. Save and restart Windsurf. 4. Verify connection in Windsurf’s MCP panel. "

[[mcpServerConf]] client = “claude” config = “1. Get your Chameleoon API key from chameleoon.sk 2. Update Claude’s configuration: { "mcpServers": { "chameleoon": { "command": "python3", "args": ["-m", "chameleoon_mcp_server"], "env": { "CHAMELEOON_API_KEY": "your_api_key_here" } } } } 3. Save and restart Claude Desktop. 4. Confirm the server appears in Claude’s integrations. "

[[mcpServerConf]] client = “cursor” config = “1. Obtain Chameleoon API credentials from chameleoon.sk 2. Edit Cursor’s MCP configuration: { "mcpServers": { "chameleoon": { "command": "python3", "args": ["-m", "chameleoon_mcp_server"], "env": { "CHAMELEOON_API_KEY": "your_api_key_here" } } } } 3. Save and restart Cursor. 4. Check server status in the MCP panel. "

[[mcpServerConf]] client = “cline” config = “1. Register for Chameleoon API access at chameleoon.sk 2. Configure Cline with MCP server details: { "mcpServers": { "chameleoon": { "command": "python3", "args": ["-m", "chameleoon_mcp_server"], "env": { "CHAMELEOON_API_KEY": "your_api_key_here" } } } } 3. Save, restart, and verify connectivity. "

[[faq]] question = “¿Qué es el servidor Chameleoon MCP?” answer = “El servidor Chameleoon MCP es un puente entre la plataforma de gestión de envíos de Chameleoon y los asistentes de IA a través del Model Context Protocol. Permite el control en lenguaje natural de las operaciones de envío, incluida la creación de pedidos, el seguimiento, la generación de etiquetas y la programación de recolecciones a través de múltiples servicios de mensajería.”

[[faq]] question = “¿Qué transportistas admite Chameleoon?” answer = “Chameleoon se integra con los principales transportistas europeos, incluyendo DPD, GLS, Packeta y otros. Puede consultar los transportistas disponibles y sus características utilizando la herramienta list_couriers para ver el soporte de recolección, las capacidades de impresión de manifiestos y las opciones de servicio.”

[[faq]] question = “¿Cómo aseguro mi clave API de Chameleoon?” answer = “Almacene siempre su CHAMELEOON_API_KEY en variables de entorno dentro de la configuración del servidor MCP. Nunca codifique las credenciales en archivos de configuración ni las envíe al control de versiones.”

[[faq]] question = “¿Puedo rastrear paquetes de múltiples transportistas?” answer = “Sí, Chameleoon proporciona URL de seguimiento universales que funcionan con todos los transportistas admitidos. El servidor enriquece automáticamente los datos de pedidos con URL de seguimiento para facilitar el monitoreo de paquetes.”

[[faq]] question = “¿Qué formatos están disponibles para las etiquetas de envío?” answer = “Chameleoon admite múltiples formatos de etiquetas: papel A4 para impresoras estándar, etiquetas térmicas A6 para impresoras de etiquetas y formato ZPL para impresoras térmicas Zebra. Puede especificar el formato al generar etiquetas.”

[[faq]] question = “¿Cómo uso este servidor MCP dentro de FlowHunt?” answer = “Agregue el componente MCP a su flujo de FlowHunt y conéctelo a su agente de IA. Configure los detalles del servidor Chameleoon MCP en formato JSON, y su agente de IA tendrá acceso a todas las capacidades de gestión de envíos para flujos de trabajo logísticos automatizados.” +++

¿Qué hace el servidor MCP “Chameleoon”?

El servidor Chameleoon MCP proporciona una integración perfecta entre la plataforma de gestión de envíos de Chameleoon y los asistentes de IA a través del Model Context Protocol (MCP). Permite a las empresas de comercio electrónico, equipos logísticos y operaciones de cumplimiento automatizar los flujos de trabajo de envío utilizando comandos en lenguaje natural. El servidor se conecta a la plataforma multi-transportista de Chameleoon, permitiendo a los asistentes de IA crear pedidos de envío, rastrear entregas a través de múltiples transportistas, generar etiquetas de envío en varios formatos, programar recolecciones de transportistas y administrar todo el ciclo de vida del envío sin navegación manual del panel. Esto transforma las operaciones logísticas complejas en simples comandos conversacionales, reduciendo drásticamente el tiempo dedicado a tareas de envío repetitivas.

Lista de Instrucciones

Creación y gestión de pedidos

Create a shipping order for John Smith at Main Street 123, Prague 10000, Czech Republic using GLS courier

Show me all shipping orders created in the last 7 days

Find all orders with status 'waiting' from DPD courier

Delete the shipping order with ID 12345

Get detailed information about order ID 67890 including tracking history

Seguimiento y monitoreo de paquetes

Track package with shipping number 06515700194651

Show me the current status and location of all orders shipped to Germany this month

Find the tracking information for reference number ORDER-2026-001

Which packages are currently in transit and when are they expected to arrive?

Show me all delivered orders from the last 14 days with their delivery dates

Generación de etiquetas de envío

Generate A4 shipping labels for orders 123, 456, and 789

Create thermal labels in A6 format for all orders ready for pickup today

Get ZPL format labels for Zebra printer for these shipping numbers: [list]

Generate labels for all GLS orders created yesterday in A4 format

Selección de transportista y servicio

List all available couriers and their features like pickup support and manifest printing

Show me which courier configurations are available for shipping to Slovakia

What are the available profiles for DPD courier?

Programación y gestión de recolecciones

Show me all orders eligible for courier pickup today

Schedule a pickup for DPD with these shipping numbers: [list]

List all pickup orders from the last 3 days grouped by courier

Validación y control de calidad

Validate this shipping order before creating it: recipient name, address, weight, and courier settings

Check if this address is valid for GLS delivery to Austria

Validate all orders waiting to be shipped and show me any with errors or warnings

List of Resources

The Chameleoon MCP Server does not expose explicit resources. All data access is tool-based.

List of Tools

The Chameleoon MCP Server provides 14 comprehensive tools organized into five categories:

Courier Management Tools

1. list_couriers

• Purpose: Retrieve available shipping couriers/carriers with their capabilities
• Parameters: None
• Returns: List of couriers with IDs, names, features (pickup support, manifest printing)
• Use Case: Determine which couriers are available before creating orders

2. list_courier_configurations

• Purpose: Get courier profiles/configurations for creating shipping orders
• Parameters: None
• Returns: Available courier configurations with profile IDs and settings
• Use Case: Find valid profile values needed for order creation

Shipping Order Tools

3. list_shipping_orders

• Purpose: List and filter shipping orders
• Parameters:
  • date_from (optional): Start date (YYYY-MM-DD)
  • date_to (optional): End date (YYYY-MM-DD)
  • reference (optional): Filter by reference number
  • status (optional): Filter by order status
  • state (optional): Filter by order state
  • courier_id (optional): Filter by courier
  • limit (optional): Max results (1-100)
  • offset (optional): Pagination offset
• Returns: Orders with tracking URLs, count, and applied filters
• Use Case: Monitor orders, find specific shipments, generate reports

4. get_shipping_order

• Purpose: Get detailed information for a specific order by internal ID
• Parameters:
  • order_id (required): Internal order identifier
• Returns: Complete order details including tracking history
• Use Case: Deep dive into specific order status and history

5. get_order_tracking

• Purpose: Track package by courier shipping/tracking number
• Parameters:
  • shipping_number (required): Courier tracking number
• Returns: Order details, tracking history, current state, recipient info, tracking URL
• Use Case: Customer service, delivery status updates

6. create_shipping_order

• Purpose: Create new shipping order with specific courier and profile
• Parameters:
  • courier_id (required): Courier identifier (e.g., ‘gls’, ‘dpd’, ‘packeta’)
  • profile (required): Profile ID from courier configurations
  • reference_number (required): Your order reference
  • recipient_name (required): Recipient full name
  • recipient_street (required): Street address
  • recipient_city (required): City
  • recipient_zip (required): Postal code
  • recipient_country (required): ISO country code (e.g., ‘SK’, ‘CZ’)
  • recipient_company (optional): Company name
  • recipient_phone (optional): Phone number
  • recipient_email (optional): Email address
  • package_weight (optional): Weight in kg
  • package_width (optional): Width in cm
  • package_height (optional): Height in cm
  • package_length (optional): Length in cm
  • cod_amount (optional): Cash on delivery amount
  • cod_currency (optional): COD currency (e.g., ‘EUR’)
  • note (optional): Note for courier
• Returns: Success confirmation, shipping number, label URL
• Use Case: Automated order fulfillment, batch shipping

7. delete_shipping_order

• Purpose: Delete a single shipping order
• Parameters:
  • order_id (required): Order ID to delete
• Returns: Success confirmation
• Use Case: Cancel mistaken orders, clean up test orders

8. delete_shipping_orders_batch

• Purpose: Delete multiple orders at once
• Parameters:
  • order_ids (required): Array of order IDs (max 20)
• Returns: Success confirmation with deleted IDs count
• Use Case: Bulk cleanup, batch cancellations

Validation Tools

9. validate_shipping_order

• Purpose: Validate order before creation to check for errors
• Parameters: Same as create_shipping_order
• Returns: Validation results with errors and warnings
• Use Case: Prevent failed orders, verify address accuracy

Shipping Label Tools

10. get_shipping_labels

• Purpose: Generate PDF shipping labels for orders
• Parameters:
  • courier_id (required): Courier identifier
  • profile (required): Courier profile
  • shipping_numbers (required): Array of shipping numbers
  • label_format (optional): ‘a4’, ‘a6’, or ‘zpl’ (default: ‘a4’)
  • position (optional): Starting position on multi-label sheets
• Returns: Base64 encoded PDF or ZPL format labels
• Use Case: Print labels for packages, automated label generation

Pickup Management Tools

11. list_pickup_orders

• Purpose: Get orders eligible for courier pickup
• Parameters:
  • date_from (optional): Start date (YYYY-MM-DD)
  • date_to (optional): End date (YYYY-MM-DD)
  • state (optional): Filter by pickup state
  • courier_id (optional): Filter by courier
• Returns: Pickup-eligible orders with tracking URLs
• Use Case: Prepare for daily pickup, schedule collections

12. create_pickup

• Purpose: Schedule courier pickup request
• Parameters:
  • courier_id (required): Courier identifier
  • shipping_numbers (required): Array of shipping numbers to collect
• Returns: Pickup confirmation, pickup number, optional manifest (base64)
• Use Case: Automate daily pickups, coordinate collections

Use Cases of this MCP Server

High-Volume Order Processing

Monday Morning Post-Weekend Rush: When processing 200+ orders accumulated over the weekend, manually creating each shipping label becomes impossible. Instead of spending 4-5 hours clicking through dashboards, use “Create shipping orders for all paid orders from Friday through Sunday using optimal courier for each destination” to process the entire batch in minutes. The AI automatically selects the best courier based on destination, validates addresses, generates labels, and provides tracking numbers - transforming a morning-consuming task into a 10-minute operation.

Flash Sale Fulfillment Crisis: Your flash sale generated 350 orders in 24 hours, and customers expect same-day shipping. Manual processing would take your entire team all day. Command “Validate all orders from flash sale batch, create shipping labels for valid addresses, and flag problematic ones for review” to instantly separate the 340 orders ready to ship from the 10 requiring address corrections. Your warehouse team can start packing immediately while customer service handles the exceptions.

Holiday Season Peak Management: During December’s peak season, you’re handling 5x normal volume with temporary staff who aren’t trained on your shipping system. Instead of training them on complex dashboards, they simply tell the AI “Create GLS shipping order for [customer name and address]” and instantly receive printed labels. This reduces training time from hours to minutes and eliminates costly shipping errors during your most critical sales period.

Multi-Courier Rate Optimization

International Order Cost Analysis: You receive 45 international orders across 12 countries. Manually checking shipping rates for each courier combination would take hours and likely result in overpaying. Ask “Compare shipping rates across all available couriers for these international destinations: [list]” and instantly see which courier offers the best rate for each country. This single analysis can save hundreds in shipping costs per day while ensuring faster delivery times.

Bulk Shipment Courier Selection: You need to ship 100 identical products to different domestic addresses. Instead of using your default courier blindly, command “Analyze courier options for 100 packages, weight 2kg each, to these addresses. Show me total cost difference between couriers including any volume discounts.” This reveals that switching from your default DPD to GLS for this batch saves 380 EUR - savings that compound across every bulk shipment.

COD Order Optimization: You have 30 cash-on-delivery orders today. Not all couriers handle COD equally - some charge higher fees, others have better success rates. Use “Which couriers support COD delivery to these addresses with the lowest combined shipping and COD fees?” to automatically route each order to the most cost-effective COD-capable courier, reducing your COD processing costs by 15-20%.

Proactive Delivery Management

Delayed Shipment Customer Communication: It’s Thursday afternoon, and you know some customers are expecting Friday deliveries. Instead of waiting for angry calls, command “Show me all packages scheduled for Friday delivery that are currently delayed or still in transit without expected delivery updates.” This identifies 12 at-risk deliveries. You proactively contact these customers with updated timelines and discount codes, transforming potential complaints into appreciation for your transparency.

Weekend Delivery Preparation: Friday at 4 PM, you need to identify which orders won’t deliver before Monday. Ask “List all orders shipped this week showing current status and estimated delivery. Flag any that won’t reach customers before Monday.” This instantly reveals 18 orders stuck in weekend transit. You send proactive Friday evening emails with Monday delivery confirmations, dramatically reducing Monday morning “where’s my order?” inquiries.

Lost Package Prevention: Instead of waiting for customers to report missing packages, run a daily check: “Show me all packages shipped more than 7 days ago without delivered status, grouped by courier.” This early warning system catches packages stuck in transit limbo before customers notice, allowing you to file courier claims and ship replacements proactively.

Warehouse Operations Efficiency

Daily Pickup Coordination Across Multiple Locations: You operate three warehouse locations, each shipping with DPD, GLS, and Packeta. Manually coordinating six separate courier pickups daily means six phone calls and juggling multiple time windows. Instead, command “Schedule pickups for all ready orders at all locations: Warsaw warehouse for DPD and GLS, Prague warehouse for all three couriers, Berlin warehouse for DPD only.” The AI schedules all pickups simultaneously, provides confirmation numbers, and generates manifests - reducing 90 minutes of phone coordination to 3 minutes of natural language instruction.

Shipping Label Printer Queue Management: Your warehouse has three packing stations: one with thermal printers (A6 labels), one with standard printers (A4 labels), and one with Zebra printers (ZPL format). Instead of manually sorting orders by station, use “Generate A6 thermal labels for orders 1-50 for station one, A4 labels for orders 51-100 for station two, and ZPL format for orders 101-120 for station three.” Each packing station instantly receives correctly formatted labels, eliminating printer compatibility errors and workflow bottlenecks.

End-of-Day Warehouse Reconciliation: Before closing at 6 PM, you need to verify all picked orders have shipping labels and all labels generated today were actually used. Command “Show me all orders marked as picked without shipping labels, and all generated labels from today not assigned to picked orders.” This reveals 3 orders missing labels (pick list completed but shipment not created) and 2 labels generated for orders still waiting to be picked - allowing you to resolve discrepancies before warehouse closure instead of discovering them the next morning.

Address Validation and Error Prevention

Bulk Order Address Verification: You received a corporate bulk order with 150 employee addresses for gift delivery. Processing these without validation risks 10-15% failure rate from typos and incomplete addresses. Instead of creating failed shipments, run “Validate all addresses in this batch before creating orders. Group results into verified addresses, correctable addresses needing minor fixes, and invalid addresses requiring customer contact.” This prevents failed deliveries, reduces return shipping costs, and allows you to resolve address issues before shipment, not after failed delivery attempts.

International Address Formatting: You’re expanding to new European markets, but each country has different address formatting requirements. A Prague address differs significantly from a Berlin or Vienna address. Instead of studying postal regulations for each country, simply command “Validate this shipping order for Czech Republic delivery” before creation. The system automatically checks street format, postal code validity, and city name consistency - preventing the frustration of packages rejected by foreign couriers due to formatting errors.

Apartment and Suite Number Detection: You notice many delivery failures are from missing apartment numbers - customers enter “Main Street 123” without “Apt 5B.” Before processing today’s 80 orders, run “Identify all addresses without apartment, suite, floor, or unit numbers in today’s orders.” This flags 12 potentially incomplete addresses. A quick verification call saves 12 failed deliveries, 12 reshipments, and 12 frustrated customers.

Customer Service Excellence

Instant Order Status for Customer Calls: Your customer service receives 50+ “where’s my order?” calls daily. Instead of each agent logging into the shipping platform, looking up orders, finding tracking numbers, checking courier websites, and explaining status, they simply ask the AI “Track package for customer John Smith, order number 2024-12345.” The AI instantly responds with current location, delivery status, and tracking URL to share - reducing average call handling time from 4 minutes to 45 seconds and dramatically improving customer satisfaction.

Batch Status Updates for VIP Customers: Your enterprise client placed an order for 200 units shipping to different locations. They want a status update on all shipments. Instead of manually checking 200 tracking numbers, use “Show delivery status for all orders with reference CLIENT-BULK-2024-001, grouped by delivered, in transit, and delayed.” Generate a formatted report in 30 seconds instead of spending 3 hours on manual tracking checks.

Return Label Generation: A customer wants to return their order. Instead of creating a return label through multiple system screens, your support agent simply says “Create a return shipping label from [customer address] to our warehouse using GLS with reference RETURN-ORDER-12345.” The customer receives their return label by email in under a minute, improving return experience and reducing support ticket resolution time.

Analytics and Cost Management

Monthly Shipping Cost Analysis: You suspect you’re overpaying on shipping but lack time to analyze hundreds of orders manually. Command “Show me all orders from last month grouped by courier, with total shipping costs, average cost per package, and delivery success rates.” This reveals that while Courier A seems cheaper per package, their 12% failed delivery rate means actual cost per successful delivery is higher than Courier B’s 98% success rate. Data-driven courier selection based on real costs, not just quoted rates.

Carrier Performance Benchmarking: You work with four couriers but lack objective performance data. Use “Compare all couriers from the last quarter: average delivery time, on-time delivery percentage, failed delivery rate, and average cost. Show me best performer for domestic versus international shipping.” This reveals DPD excels at domestic speed but GLS offers better international reliability - allowing you to route orders strategically instead of using a one-size-fits-all approach.

Delivery Zone Optimization: You’re considering opening a second warehouse to improve delivery times. Before investing, ask “Analyze delivery times to all postal codes we ship to, grouped by region. Show average transit days and identify areas with consistently slow delivery.” This geographic analysis reveals that 60% of your 3+ day deliveries go to southeastern regions - validating the business case for a regional distribution center and projecting potential delivery time improvements.

Seasonal and Promotional Campaign Support

Pre-Campaign Capacity Planning: You’re launching a “Free Shipping Friday” promotion expecting 3x normal order volume. Ask “Based on current courier pickup capacity and scheduling, how many orders can each courier handle if we receive 600 orders on Friday? What’s our maximum processing capacity?” This reveals your current courier agreements support 450 orders maximum. You proactively arrange additional pickup capacity with couriers before the promotion launches, preventing the fulfillment crisis that plagued last year’s promotion.

Gift Season Multi-Recipient Orders: During holidays, many customers order gifts shipping to different recipients. Instead of manually creating 8 separate shipments for one customer’s gift list, use “Create shipping orders for customer ORDER-HOLIDAY-789: 8 different recipients at these addresses, all using gift packaging note and same billing reference.” Process complex multi-recipient orders in seconds while maintaining accurate order attribution for customer service and accounting.

Same-Day Shipping Deadline Management: You promise same-day shipping for orders placed before 2 PM. At 1:45 PM, you need to know exactly which orders are cutting it close. Command “Show me all paid orders from today without shipping labels created yet. How many can we process and schedule pickup for same-day shipping?” This reveals 23 orders need immediate attention. You prioritize these before the 2 PM cutoff, maintaining your same-day shipping promise and competitive advantage.

How to set it up

Prerequisites

• Python 3.10 or higher installed
• Chameleoon account with API access (register at chameleoon.sk)
• Valid CHAMELEOON_API_KEY

Windsurf

1. Obtain your Chameleoon API key:

   • Log in to your Chameleoon account at chameleoon.sk
   • Navigate to Settings > API Access
   • Generate or copy your API key

2. Locate Windsurf’s MCP configuration file:

   • macOS: ~/Library/Application Support/Windsurf/mcp.json
   • Windows: %APPDATA%\Windsurf\mcp.json
   • Linux: ~/.config/Windsurf/mcp.json

3. Add the Chameleoon MCP server configuration:

   {
     "mcpServers": {
       "chameleoon": {
         "command": "python3",
         "args": ["-m", "chameleoon_mcp_server"],
         "env": {
           "CHAMELEOON_API_KEY": "your_api_key_here"
         }
       }
     }
   }
   

4. Save the configuration file and restart Windsurf completely.

5. Verify the connection:

   • Open Windsurf’s MCP panel
   • Look for “chameleoon” in the list of active servers
   • Try a test command: “List available couriers”

Claude Desktop

1. Get your Chameleoon API credentials from chameleoon.sk (see Prerequisites).

2. Locate Claude Desktop’s configuration:

   • macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
   • Windows: %APPDATA%\Claude\claude_desktop_config.json
   • Linux: ~/.config/Claude/claude_desktop_config.json

3. Update or create the configuration file:

   {
     "mcpServers": {
       "chameleoon": {
         "command": "python3",
         "args": ["-m", "chameleoon_mcp_server"],
         "env": {
           "CHAMELEOON_API_KEY": "your_api_key_here"
         }
       }
     }
   }
   

4. Save the file and fully restart Claude Desktop (quit and relaunch).

5. Confirm the server connection:

   • Open Claude Desktop
   • Look for the MCP integrations panel
   • Verify “Chameleoon MCP Server” appears as connected
   • Test with: “Show me the list of available shipping couriers”

Cursor

1. Register and obtain API access at chameleoon.sk (see Prerequisites).

2. Find Cursor’s MCP configuration file:

   • macOS: ~/Library/Application Support/Cursor/mcp.json
   • Windows: %APPDATA%\Cursor\mcp.json
   • Linux: ~/.config/Cursor/mcp.json

3. Add the MCP server entry:

   {
     "mcpServers": {
       "chameleoon": {
         "command": "python3",
         "args": ["-m", "chameleoon_mcp_server"],
         "env": {
           "CHAMELEOON_API_KEY": "your_api_key_here"
         }
       }
     }
   }
   

4. Save and restart Cursor.

5. Check server status:

   • Open Cursor’s MCP panel (View > MCP Servers)
   • Ensure “chameleoon” shows as active
   • Try: “List my shipping orders from this week”

Cline

1. Obtain Chameleoon API key from chameleoon.sk.

2. Locate Cline’s configuration file (location varies by Cline installation).

3. Add the Chameleoon MCP server:

   {
     "mcpServers": {
       "chameleoon": {
         "command": "python3",
         "args": ["-m", "chameleoon_mcp_server"],
         "env": {
           "CHAMELEOON_API_KEY": "your_api_key_here"
         }
       }
     }
   }
   

4. Save, restart Cline, and verify the server appears in available MCP servers.

5. Test connectivity: “Get list of courier configurations”

Security Best Practices

Never hardcode API keys. Always use environment variables:

{
  "mcpServers": {
    "chameleoon": {
      "command": "python3",
      "args": ["-m", "chameleoon_mcp_server"],
      "env": {
        "CHAMELEOON_API_KEY": "${CHAMELEOON_API_KEY}"
      }
    }
  }
}

Then set the environment variable at the system level:

• macOS/Linux: Add to ~/.bashrc or ~/.zshrc: export CHAMELEOON_API_KEY="your_key"
• Windows: Set via System Properties > Environment Variables

Restrict API key permissions in your Chameleoon account to only the operations needed.

Rotate keys regularly and revoke old keys immediately if compromised.

Use separate keys for development, staging, and production environments.

How to use this MCP inside flows

Using MCP in FlowHunt

To integrate the Chameleoon MCP Server into your FlowHunt workflow for automated shipping operations, follow these steps:

1. Add the MCP Component:
   • Open your FlowHunt flow or create a new one
   • Drag the MCP component from the components panel
   • Connect it to your AI agent component

2. Configure the MCP Server:
   • Click on the MCP component to open configuration
   • In the system MCP configuration section, insert your Chameleoon MCP server details:

{
  "chameleoon": {
    "transport": "streamable_http",
    "url": "https://yourmcpserver.example/path/to/chameleoon/mcp"
  }
}

Replace the URL with your actual Chameleoon MCP server endpoint.

3. Set Up Environment Variables:

   • In FlowHunt’s environment settings, add:
     • Key: CHAMELEOON_API_KEY
     • Value: Your Chameleoon API key

4. Configure Your AI Agent: Once connected, your AI agent can use natural language to control shipping operations. Example prompts:

   • “Create a shipping order for customer John Smith at…”
   • “Track all orders from yesterday”
   • “Generate labels for orders waiting for shipment”
   • “Schedule a pickup for DPD orders”

5. Build Automated Workflows:

   Example: Order Fulfillment Flow

   • Trigger: New order in e-commerce system
   • Action 1: Extract customer address and order details
   • Action 2: MCP component instructs AI: “Create shipping order with these details: [order data]”
   • Action 3: Store shipping number and tracking URL
   • Action 4: Send confirmation email to customer with tracking link

   Example: Daily Shipping Report

   • Trigger: Schedule (daily at 9 AM)
   • Action 1: MCP component asks AI: “List all orders from yesterday”
   • Action 2: Analyze data for insights
   • Action 3: Generate summary report
   • Action 4: Send to logistics team

   Example: Customer Service Automation

   • Trigger: Customer inquiry with order number
   • Action 1: Extract order number from message
   • Action 2: MCP component: “Track package with reference [order_number]”
   • Action 3: Format tracking information
   • Action 4: Send response to customer with status and tracking URL

MCP Server Evaluation

Overview

Our opinion

The Chameleoon MCP Server delivers a robust, production-ready integration for shipping management automation. It stands out with comprehensive tool coverage across the entire shipping lifecycle - from courier selection and order creation to tracking, label generation, and pickup scheduling.

Strengths:

• Complete Coverage: 14 well-designed tools covering all shipping operations
• Multi-Courier Support: Works with DPD, GLS, Packeta, and other European carriers
• Practical Features: Universal tracking URLs, multiple label formats, batch operations
• Business-Focused: Clear use cases for e-commerce, logistics, and small businesses
• Security-Conscious: Environment variable configuration, no hardcoded credentials

Best For:

• E-commerce businesses automating order fulfillment
• Logistics teams managing multi-courier operations
• Small businesses seeking shipping automation without complex APIs
• Developers building shipping workflows in FlowHunt or similar platforms
• Customer service teams needing quick access to tracking information

Limitations:

• Regional focus (primarily European couriers)
• Requires Chameleoon account and API access
• No exposed resources (all access is tool-based)

The server transforms complex shipping API interactions into simple natural language commands, making advanced logistics automation accessible to non-technical users while providing power users with comprehensive programmatic control.

MCP Score

Note: Fork and star counts are not available as this is an internal/proprietary MCP server implementation.