How to Query Your MDM Fleet Using the New Android Management API MCP Server

In February 2026, Google fundamentally changed how IT administrators interact with their device fleets by launching the Android Management API MCP Server. By leveraging the Model Context Protocol (MCP), this integration allows you to perform complex MDM natural language queries directly through AI assistants like Claude, ChatGPT, or your enterprise's internal LLM tools.

Instead of manually writing complex JSON requests or navigating through multi-layered dashboards, you can now execute an AI device compliance check simply by typing: "Show me all rugged scanners in the warehouse that are missing the latest security patch."

As an official Android Enterprise Partner, Nomid MDM has optimized our platform to work seamlessly with the new AMAPI MCP Server. Whether you are deploying Zero-Touch Enrollment devices in healthcare, managing Samsung Knox tablets in retail, or tracking rugged devices in logistics, this guide will show you exactly how to configure your AMAPI MCP client setup for lightning-fast, AI-driven fleet management.

Prerequisites for Your AMAPI MCP Client Setup

Before you begin the integration, ensure you have the following components ready:

• Google Cloud Project (GCP): A project with the Android Management API enabled.
• Enterprise ID: Your existing Android Enterprise ID (available in your Nomid MDM console under Settings> Android Enterprise).
• MCP Client: A compatible client environment (e.g., Claude Desktop App, Cursor, or a custom LLM interface).
• Development Environment: Node.js (v18 or higher) and npm installed on your local machine or server.

Note: If you are a current Nomid MDM customer, your Dedicated Success Manager can provide a pre-configured GCP service account JSON file, allowing you to skip Step 1.

Step 1: Generate Google Cloud Service Account Credentials

To allow the MCP Server to securely query your device fleet, you must provide it with authenticated access to your Google Cloud Project.

1. Navigate to the Google Cloud Console and select the project tied to your Android Enterprise environment.
2. Go to IAM & Admin> Service Accounts.
3. Click + CREATE SERVICE ACCOUNT at the top of the screen.
4. Name the account amapi-mcp-service and provide a brief description. Click Create and Continue.
5. In the Role dropdown, select Android Management User. This provides the necessary read/write permissions for device and policy queries. Click Continue, then Done.
6. Locate your newly created service account in the list, click the three-dot menu under the Actions column, and select Manage keys.
7. Click ADD KEY> Create new key. Select JSON as the key type and click Create.
8. Save the downloaded JSON file to a secure directory on your machine (e.g., ~/.config/nomid-mdM/amapi-credentials.json).

Warning: Never commit your Service Account JSON file to a public or shared repository. This file grants direct administrative access to your entire Android device fleet.

Expected result: You possess a valid JSON credential file downloaded to your local machine, and your GCP service account is authorized to interact with the Android Management API.

Step 2: Install and Build the Android Management API MCP Server

Next, you will download and compile the official Google AMAPI MCP server repository. This server acts as the translation layer between your AI's natural language and the RESTful endpoints of the Android Management API.

Open your terminal or command prompt.

Clone the official repository (or the Nomid-enhanced fork for advanced Zero-Touch and Knox features):

git clone https://github.com/google/android-management-api-mcp.git
cd android-management-api-mcp

Install the necessary Node.js dependencies:

npm install

Build the MCP server executable:

npm run build

Verify the build by checking for the compiled output in the build/ directory:

ls -la build/index.js

Step 3: Configure Your MCP Client Integration

You must now connect your AI client to the MCP server you just built. In this tutorial, we will use the Claude Desktop app as our MCP client, but the Model Context Protocol Android configuration is universally applicable to any compliant client.

Locate your Claude Desktop configuration file.

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

Open the file in your preferred text editor. If the file does not exist, create it.

Add the AMAPI MCP server configuration. You must define the path to your Node executable, the path to the built MCP server, and pass your GCP credentials and Enterprise ID as environment variables.

{
  "mcpServers": {
    "amapi": {
      "command": "node",
      "args": [
        "/path/to/your/android-management-api-mcp/build/index.js"
      ],
      "env": {
        "GOOGLE_APPLICATION_CREDENTIALS": "/path/to/your/amapi-credentials.json",
        "ANDROID_ENTERPRISE_ID": "LC0123456789"
      }
    }
  }
}

Replace /path/to/your/... with the absolute paths on your system, and replace LC0123456789 with your actual Nomid MDM Enterprise ID.

Save the file and completely restart your Claude Desktop application to initialize the MCP connection.

Note: To verify the connection, look for the "plug" icon in the Claude interface, which indicates active MCP servers. You should see "amapi" listed with its available tools (e.g., list_devices, get_device, check_compliance).

Expected result: Your MCP client successfully connects to the AMAPI server on startup, loading the necessary tools and authenticating via your service account credentials.

Step 4: Execute Natural Language Queries for Device Compliance

With the Android Enterprise AI integration complete, you can now query your Nomid MDM fleet management system using conversational prompts. The MCP server translates your text into precise enterprises.devices.list API calls, analyzes the JSON response, and returns a human-readable summary.

1. Open a new chat in your MCP client.
2. Test a basic inventory query. Type: "List the top 5 devices in my enterprise, including their manufacturer, model, and current battery level."
3. Run an AI device compliance check. Type: "Analyze my fleet and show me all devices that are currently non-compliant. Group them by the specific policy rule they are violating (e.g., password quality, outdated OS)."
4. Execute an industry-specific query. Depending on your vertical, try one of the following:

• Healthcare:"Find all Zebra TC52 devices assigned to the 'Nursing Staff' policy that have not checked in with the MDM in the last 24 hours."
• Retail:"Which Samsung Galaxy Tab Active4 Pro devices acting as mobile point-of-sale (mPOS) kiosks have a battery health status below 'GOOD'?"
• Logistics:"List all rugged scanners currently outside the geofence defined in the 'Warehouse A' policy."

Expected result: The AI assistant executes the tool, retrieves real-time data from the Android Management API, and presents a neatly formatted, highly accurate response based on your fleet's live status.

Step 5: Leverage Nomid MDM's Advanced MCP Context (Zero-Touch & Knox)

Standard AMAPI MCP servers provide excellent baseline visibility. However, as an Android Enterprise Partner, Nomid MDM extends this capability. By using the Nomid MDM MCP Plugin, you can query proprietary enrollment and hardware-level data.

1. In your Nomid MDM console, navigate to Integrations > AI & MCP and generate a Nomid API Token.
2. Update your claude_desktop_config.json to include the Nomid extension:

"env": {
  "GOOGLE_APPLICATION_CREDENTIALS": "/path/to/your/amapi-credentials.json",
  "ANDROID_ENTERPRISE_ID": "LC0123456789",
  "NOMID_API_KEY": "nomid_live_xxxxxxxxx",
  "ENABLE_KNOX_FEATURES": "true",
  "ENABLE_ZTE_FEATURES": "true"
}

1. Restart your MCP client.
2. You can now prompt the AI for advanced deployment states. Try typing:

"Check the Zero-Touch Enrollment portal and tell me how many Pixel 8 devices are assigned to our enterprise but haven't been booted up yet."

or

"Query Samsung Knox Mobile Enrollment (KME) and list any devices that failed to apply the Nomid MDM profile during initial setup."

Expected result: Your AI assistant seamlessly blends standard AMAPI data with Nomid MDM's Zero-Touch and Samsung Knox APIs, providing a unified, natural language command center for your entire hardware lifecycle.

Troubleshooting FAQ

1. Why is my MCP client returning a "403 Forbidden" or "401 Unauthorized" error?

This almost always indicates an issue with your Service Account JSON file. Ensure that:

• The absolute path in your claude_desktop_config.json is 100% correct.
• The Service Account has the Android Management User role assigned in GCP IAM.
• The Android Management API is actually enabled in the GCP project where the Service Account resides.

2. The AI says "No devices found," but I know I have devices enrolled.

Check the ANDROID_ENTERPRISE_ID in your configuration. It must exactly match the ID of the enterprise you are trying to query. Additionally, ensure the devices are enrolled under the AMAPI framework, not a legacy Device Administrator setup.

3. My MCP client times out when asking for a full fleet compliance report.

If you are managing a massive fleet (e.g., 10,000+ logistics scanners), asking the AI to "list all devices" will cause the MCP server to hit AMAPI pagination limits and timeout the LLM context window. Instead, use specific, filtered prompts like: "List the first 50 non-compliant devices" or "Summarize the compliance status counts without listing individual device names."

4. Can the MCP Server issue commands, like wiping a device?

Conclusion: The Future of Fleet Management is Conversational

The February 2026 release of the Android Management API MCP Server represents a massive leap forward for IT operations. By integrating MDM natural language queries into your workflow, you eliminate the friction of navigating complex dashboards and manually parsing API logs. You can now perform a comprehensive AI device compliance check in seconds, freeing up your IT team to focus on strategic initiatives rather than basic troubleshooting.

To truly maximize the potential of the Model Context Protocol Android integration, you need an MDM provider built for the AI era. Nomid MDM not only supports seamless AMAPI MCP client setup, but our exclusive plugins for Zero-Touch Enrollment and Samsung Knox give your AI assistants unprecedented visibility into every stage of your device lifecycle.

Ready to modernize your Android fleet management? Contact the Nomid MDM team today to schedule a demo of our AI-integrated platform and see how conversational MDM can transform your enterprise operations.