Skip to main content
Glama
concavegit

App Store Connect MCP Server

by concavegit

list_users

Retrieve all registered users on your App Store Connect team with options to filter by role, username, or visible apps, sort results, and control response details.

Instructions

Get a list of all users registered on your App Store Connect team

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
limitNoMaximum number of users to return (default: 100, max: 200)
sortNoSort order for the results
filterNo
includeNoRelated resources to include in the response

Implementation Reference

  • The core handler function listUsers that implements the tool logic by constructing query parameters and calling the App Store Connect API endpoint '/users'.
    async listUsers(args: {
      limit?: number;
      sort?: UserSortOptions;
      filter?: UserFilters;
      include?: UserIncludeOptions[];
    } = {}): Promise<ListUsersResponse> {
      const { limit = 100, sort, filter, include } = args;
      
      const params: Record<string, any> = {
        limit: sanitizeLimit(limit)
      };
    
      if (sort) {
        params.sort = sort;
      }
    
      Object.assign(params, buildFilterParams(filter));
    
      if (Array.isArray(include) && include.length > 0) {
        params.include = include.join(',');
      }
    
      return this.client.get<ListUsersResponse>('/users', params);
    }
  • src/index.ts:1384-1385 (registration)
    Registration of the 'list_users' tool handler in the MCP server's CallToolRequest handler switch statement, dispatching to userHandlers.listUsers.
    case "list_users":
      return { toolResult: await this.userHandlers.listUsers(args as any) };
  • Tool registration including input schema definition for 'list_users' in the buildToolsList method, advertised to MCP clients.
    {
      name: "list_users",
      description: "Get a list of all users registered on your App Store Connect team",
      inputSchema: {
        type: "object",
        properties: {
          limit: {
            type: "number",
            description: "Maximum number of users to return (default: 100, max: 200)",
            minimum: 1,
            maximum: 200
          },
          sort: {
            type: "string",
            description: "Sort order for the results",
            enum: ["username", "-username", "firstName", "-firstName", "lastName", "-lastName", "roles", "-roles"]
          },
          filter: {
            type: "object",
            properties: {
              username: { type: "string", description: "Filter by username" },
              roles: {
                type: "array",
                items: {
                  type: "string",
                  enum: [
                    "ADMIN", "FINANCE", "TECHNICAL", "SALES", "MARKETING", "DEVELOPER",
                    "ACCOUNT_HOLDER", "READ_ONLY", "APP_MANAGER", "ACCESS_TO_REPORTS", "CUSTOMER_SUPPORT"
                  ]
                },
                description: "Filter by user roles"
              },
              visibleApps: {
                type: "array",
                items: { type: "string" },
                description: "Filter by apps the user can see (app IDs)"
              }
            }
          },
          include: {
            type: "array",
            items: {
              type: "string",
              enum: ["visibleApps"]
            },
            description: "Related resources to include in the response"
          }
        }
      }
    },
  • TypeScript interface defining the output structure ListUsersResponse used by the listUsers handler.
    export interface ListUsersResponse {
      data: User[];
    }
  • src/index.ts:78-78 (registration)
    Instantiation of the UserHandlers class instance used for the list_users tool.
    this.userHandlers = new UserHandlers(this.client);
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries full burden for behavioral disclosure but only states the basic purpose. It doesn't mention whether this is a read-only operation, potential rate limits, authentication requirements, pagination behavior, or what the response format looks like. For a list operation with 4 parameters, this leaves significant behavioral gaps.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence that states the core purpose without unnecessary words. It's appropriately sized and front-loaded with the essential information.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool has 4 parameters, no annotations, and no output schema, the description is insufficiently complete. It doesn't explain what the tool returns, how results are structured, or provide context about the App Store Connect team environment. For a list operation with filtering capabilities, more guidance is needed.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The description adds no parameter information beyond what the schema provides. With 75% schema description coverage (3 of 4 parameters have descriptions), the baseline is 3. The description doesn't compensate for the 25% gap or provide additional context about parameter interactions or usage patterns.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action ('Get a list') and resource ('all users registered on your App Store Connect team'), providing specific verb+resource pairing. However, it doesn't differentiate from sibling tools like 'list_group_testers' or 'list_devices' which also list different types of entities, so it misses full sibling differentiation.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention any prerequisites, exclusions, or suggest other tools for different scenarios (e.g., filtering users by specific criteria beyond what parameters allow).

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Install Server

Other Tools

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/concavegit/app-store-connect-mcp-server'

If you have feedback or need assistance with the MCP directory API, please join our Discord server