+++ 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 = “Automatisez les opérations d’expédition et la gestion de la livraison de colis avec l’IA en utilisant le serveur Chameleoon MCP. Intégrez-vous avec plusieurs transporteurs, suivez les expéditions, générez des étiquettes et gérez les enlèvements via des commandes en langage naturel dans des outils comme Claude, Cursor, Windsurf et FlowHunt.” image = “/images/hosted-mcp-servers/biznisweb.webp” shortDescription = “Rationalisez les opérations d’expédition et les flux de travail logistiques avec l’automatisation alimentée par l’IA. Le serveur Chameleoon MCP connecte votre assistant IA à la gestion multi-transporteurs, au suivi des colis, à la génération d’étiquettes et à la planification des enlèvements.” tags = [ “Shipping”, “Logistics”, “E-commerce”, “MCP”, “AI Integration”, “Automation” ] categories = [ “Integrations”, “MCP Servers” ] showCTA = true ctaHeading = “Essayez le serveur Chameleoon MCP avec FlowHunt” ctaDescription = “Transformez vos flux de travail d’expédition avec l’automatisation IA. Gérez les commandes entre plusieurs transporteurs, suivez les livraisons et optimisez les opérations logistiques directement depuis vos outils préférés.” ctaPrimaryText = “Essayez maintenant” ctaPrimaryURL = “https://app.flowhunt.io/sign-in" ctaSecondaryText = “Réserver une démo” 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’est-ce que le serveur Chameleoon MCP?” answer = “Le serveur Chameleoon MCP est un pont entre la plateforme de gestion d’expédition de Chameleoon et les assistants IA via le Model Context Protocol. Il permet le contrôle en langage naturel des opérations d’expédition, y compris la création de commandes, le suivi, la génération d’étiquettes et la planification des enlèvements à travers plusieurs services de transport.”

[[faq]] question = “Quels transporteurs Chameleoon prend-il en charge?” answer = “Chameleoon s’intègre avec les principaux transporteurs européens, notamment DPD, GLS, Packeta et d’autres. Vous pouvez interroger les transporteurs disponibles et leurs fonctionnalités en utilisant l’outil list_couriers pour voir le support d’enlèvement, les capacités d’impression de manifeste et les options de service.”

[[faq]] question = “Comment sécuriser ma clé API Chameleoon?” answer = “Stockez toujours votre CHAMELEOON_API_KEY dans les variables d’environnement dans la configuration du serveur MCP. Ne codez jamais en dur les informations d’identification dans les fichiers de configuration et ne les validez pas dans le contrôle de version.”

[[faq]] question = “Puis-je suivre les colis de plusieurs transporteurs?” answer = “Oui, Chameleoon fournit des URL de suivi universelles qui fonctionnent avec tous les transporteurs pris en charge. Le serveur enrichit automatiquement les données de commande avec des URL de suivi pour faciliter la surveillance des colis.”

[[faq]] question = “Quels formats sont disponibles pour les étiquettes d’expédition?” answer = “Chameleoon prend en charge plusieurs formats d’étiquettes: papier A4 pour les imprimantes standard, étiquettes thermiques A6 pour les imprimantes d’étiquettes et format ZPL pour les imprimantes thermiques Zebra. Vous pouvez spécifier le format lors de la génération d’étiquettes.”

[[faq]] question = “Comment utiliser ce serveur MCP dans FlowHunt?” answer = “Ajoutez le composant MCP à votre flux FlowHunt et connectez-le à votre agent IA. Configurez les détails du serveur Chameleoon MCP au format JSON, et votre agent IA aura accès à toutes les capacités de gestion d’expédition pour les flux de travail logistiques automatisés.” +++

Que fait le serveur MCP “Chameleoon”?

Le serveur Chameleoon MCP fournit une intégration transparente entre la plateforme de gestion d’expédition de Chameleoon et les assistants IA via le Model Context Protocol (MCP). Il permet aux entreprises de commerce électronique, aux équipes logistiques et aux opérations d’exécution d’automatiser les flux de travail d’expédition en utilisant des commandes en langage naturel. Le serveur se connecte à la plateforme multi-transporteurs de Chameleoon, permettant aux assistants IA de créer des commandes d’expédition, de suivre les livraisons sur plusieurs transporteurs, de générer des étiquettes d’expédition dans différents formats, de planifier les enlèvements de transporteurs et de gérer l’ensemble du cycle de vie d’expédition sans navigation manuelle dans le tableau de bord. Cela transforme les opérations logistiques complexes en simples commandes conversationnelles, réduisant considérablement le temps consacré aux tâches d’expédition répétitives.

Liste des Invites

Création et gestion des commandes

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

Suivi et surveillance des colis

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

Génération d’étiquettes d’expédition

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

Sélection du transporteur et du service

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?

Planification et gestion des enlèvements

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

Validation et contrôle qualité

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.