Azure Mgmt Apimanagement Py

MicrosoftOfficialCreated by Microsoft

Skill
Tool integration
Cloud and DevOps
MIT
Low risk

From the author

Azure API Management SDK for Python. Use for managing APIM services, APIs, products, subscriptions, and policies. Triggers: "azure-mgmt-apimanagement", "ApiManagementClient", "APIM", "API gateway", "API Management".

— the description by Microsoft

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

The azure-mgmt-apimanagement-py skill provides a structured approach to automating the lifecycle and configuration of Azure API Management (APIM) services. It covers essential operations including service provisioning, API importing from OpenAPI definitions, product management, subscription handling, and policy enforcement. The skill emphasizes secure authentication practices using DefaultAzureCredential and resource management through context managers to ensure proper lifecycle handling of network connections and credentials.

What it does

Provision and configure Azure API Management service instances.
Import APIs from OpenAPI specifications or external URLs.
Manage products, subscriptions, and user access within APIM.
Define and apply custom API policies for request handling.
Configure backend services and named values for secrets.
Organize operations across various APIM management groups.

When to use it

When automating the deployment of API gateways in Azure.
When integrating API management configuration into CI/CD pipelines.
When programmatically managing API products and subscription keys.
When applying consistent security or transformation policies across multiple APIs.

Advantages

Promotes secure authentication practices using Entra-integrated credentials.
Ensures resource safety through mandatory context manager usage.
Provides granular control over API lifecycle and policy management.
Supports both synchronous and asynchronous programming patterns.

Usage examples

“How do I import an API into Azure API Management using an OpenAPI JSON file?”: The agent provides a code snippet using the ApiCreateOrUpdateParameter model to define the API display name, path, and the OpenAPI JSON content, then calls the client.api.begin_create_or_update method.
“Show me how to set a rate limit policy on an existing API.”: The agent provides a Python example using the PolicyContract model to inject an XML policy string containing the rate-limit element, applied via the client.api_policy.create_or_update method.
“How do I create a new product in APIM and add an API to it?”: The agent demonstrates creating a product with ProductContract and then using the client.product_api.create_or_update method to associate a specific API ID with that product.
“What is the best way to authenticate with the APIM client in production?”: The agent explains the use of DefaultAzureCredential and recommends setting the AZURE_TOKEN_CREDENTIALS environment variable to 'prod' to restrict the credential chain.

Install

Download the skill as a ZIP:
https://mp-staging.autogineer.com/agent-skills/microsoft/azure-mgmt-apimanagement-py/download

Unzip it into the cross-client skills folder of your project:

mkdir -p .agents/skills && unzip azure-mgmt-apimanagement-py.zip -d .agents/skills

Documentation by Microsoft

Azure API Management SDK for Python

Manage Azure API Management services, APIs, products, and policies.

Installation

pip install azure-mgmt-apimanagement
pip install azure-identity

Environment Variables

AZURE_SUBSCRIPTION_ID=your-subscription-id  # Required for all auth methods
AZURE_TOKEN_CREDENTIALS=prod # Required only if DefaultAzureCredential is used in production

Authentication & Lifecycle

🔑 Two rules apply to every code sample below:
Prefer DefaultAzureCredential. It works locally (Azure CLI / VS Code / Developer CLI) and in Azure (managed identity, workload identity) with no code change. Avoid connection strings, account/API keys — they bypass Entra audit and rotation.
Local dev: DefaultAzureCredential works as-is.
Production: set AZURE_TOKEN_CREDENTIALS=prod (or AZURE_TOKEN_CREDENTIALS=<specific_credential>) to constrain the credential chain to production-safe credentials.
Wrap every client in a context manager so HTTP transports, sockets, and token caches are released deterministically:
Sync: with <Client>(...) as client:
Async: async with <Client>(...) as client: and async with DefaultAzureCredential() as credential: (from azure.identity.aio)
Snippets may abbreviate this setup, but production code should always follow both rules.

from azure.identity import DefaultAzureCredential
from azure.mgmt.apimanagement import ApiManagementClient
import os

with ApiManagementClient(
    credential=DefaultAzureCredential(),
    subscription_id=os.environ["AZURE_SUBSCRIPTION_ID"]
) as client:
    # Use `client` for all subsequent operations (see examples below)
    ...

Create APIM Service

from azure.mgmt.apimanagement.models import (
    ApiManagementServiceResource,
    ApiManagementServiceSkuProperties,
    SkuType
)

service = client.api_management_service.begin_create_or_update(
    resource_group_name="my-resource-group",
    service_name="my-apim",
    parameters=ApiManagementServiceResource(
        location="eastus",
        publisher_email="[email protected]",
        publisher_name="My Organization",
        sku=ApiManagementServiceSkuProperties(
            name=SkuType.DEVELOPER,
            capacity=1
        )
    )
).result()

print(f"Created APIM: {service.name}")

Import API from OpenAPI

from azure.mgmt.apimanagement.models import (
    ApiCreateOrUpdateParameter,
    ContentFormat,
    Protocol
)

api = client.api.begin_create_or_update(
    resource_group_name="my-resource-group",
    service_name="my-apim",
    api_id="my-api",
    parameters=ApiCreateOrUpdateParameter(
        display_name="My API",
        path="myapi",
        protocols=[Protocol.HTTPS],
        format=ContentFormat.OPENAPI_JSON,
        value='{"openapi": "3.0.0", "info": {"title": "My API", "version": "1.0"}, "paths": {"/health": {"get": {"responses": {"200": {"description": "OK"}}}}}}'
    )
).result()

print(f"Imported API: {api.display_name}")

Import API from URL

api = client.api.begin_create_or_update(
    resource_group_name="my-resource-group",
    service_name="my-apim",
    api_id="petstore",
    parameters=ApiCreateOrUpdateParameter(
        display_name="Petstore API",
        path="petstore",
        protocols=[Protocol.HTTPS],
        format=ContentFormat.OPENAPI_LINK,
        value="https://petstore.swagger.io/v2/swagger.json"
    )
).result()

List APIs

apis = client.api.list_by_service(
    resource_group_name="my-resource-group",
    service_name="my-apim"
)

for api in apis:
    print(f"{api.name}: {api.display_name} - {api.path}")

Create Product

from azure.mgmt.apimanagement.models import ProductContract

product = client.product.create_or_update(
    resource_group_name="my-resource-group",
    service_name="my-apim",
    product_id="premium",
    parameters=ProductContract(
        display_name="Premium",
        description="Premium tier with unlimited access",
        subscription_required=True,
        approval_required=False,
        state="published"
    )
)

print(f"Created product: {product.display_name}")

Add API to Product

client.product_api.create_or_update(
    resource_group_name="my-resource-group",
    service_name="my-apim",
    product_id="premium",
    api_id="my-api"
)

Create Subscription

from azure.mgmt.apimanagement.models import SubscriptionCreateParameters

subscription = client.subscription.create_or_update(
    resource_group_name="my-resource-group",
    service_name="my-apim",
    sid="my-subscription",
    parameters=SubscriptionCreateParameters(
        display_name="My Subscription",
        scope=f"/products/premium",
        state="active"
    )
)

print(f"Subscription key: {subscription.primary_key}")

Set API Policy

from azure.mgmt.apimanagement.models import PolicyContract

policy_xml = """
<policies>
    <inbound>
        <rate-limit calls="100" renewal-period="60" />
        <set-header name="X-Custom-Header" exists-action="override">
            <value>CustomValue</value>
        </set-header>
    </inbound>
    <backend>
        <forward-request />
    </backend>
    <outbound />
    <on-error />
</policies>
"""

client.api_policy.create_or_update(
    resource_group_name="my-resource-group",
    service_name="my-apim",
    api_id="my-api",
    policy_id="policy",
    parameters=PolicyContract(
        value=policy_xml,
        format="xml"
    )
)

Create Named Value (Secret)

from azure.mgmt.apimanagement.models import NamedValueCreateContract

named_value = client.named_value.begin_create_or_update(
    resource_group_name="my-resource-group",
    service_name="my-apim",
    named_value_id="backend-api-key",
    parameters=NamedValueCreateContract(
        display_name="Backend API Key",
        value="secret-key-value",
        secret=True
    )
).result()

Create Backend

from azure.mgmt.apimanagement.models import BackendContract

backend = client.backend.create_or_update(
    resource_group_name="my-resource-group",
    service_name="my-apim",
    backend_id="my-backend",
    parameters=BackendContract(
        url="https://api.backend.example.com",
        protocol="http",
        description="My backend service"
    )
)

Create User

from azure.mgmt.apimanagement.models import UserCreateParameters

user = client.user.create_or_update(
    resource_group_name="my-resource-group",
    service_name="my-apim",
    user_id="newuser",
    parameters=UserCreateParameters(
        email="[email protected]",
        first_name="John",
        last_name="Doe"
    )
)

Operation Groups

Group	Purpose
`api_management_service`	APIM instance management
`api`	API operations
`api_operation`	API operation details
`api_policy`	API-level policies
`product`	Product management
`product_api`	Product-API associations
`subscription`	Subscription management
`user`	User management
`named_value`	Named values/secrets
`backend`	Backend services
`certificate`	Certificates
`gateway`	Self-hosted gateways

Best Practices

Pick sync OR async and stay consistent. Do not mix azure.xxx sync clients with azure.xxx.aio async clients in the same call path. Choose one mode per module.
Always use context managers for clients and async credentials. Wrap every client in with Client(...) as client: (sync) or async with Client(...) as client: (async). For async DefaultAzureCredential from azure.identity.aio, also use async with credential: so tokens and transports are cleaned up.
Use named values for secrets and configuration
Apply policies at appropriate scopes (global, product, API, operation)
Use products to bundle APIs and manage access
Enable Application Insights for monitoring
Use backends to abstract backend services
Version your APIs using APIM's versioning features

Reference Files

File	Contents
references/capabilities.md	Additional non-hero capabilities, operation-group coverage, and production checklists.
references/non-hero-scenarios.md	Dedicated non-hero examples for secondary/advanced scenarios.

Files

ATTRIBUTION.mdAdded by AutoGineer992 B
LICENSELicence file added by AutoGineer1.1 KiB
SKILL.md8.7 KiB
references/capabilities.md2.2 KiB
references/non-hero-scenarios.md3.7 KiB

Requirements and compatibility

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Needs: Needs an API key, Needs Python

Security

What our scanner noticed· Low risk

Instructions that use the network

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

Created by

Microsoft

Publisher

Microsoft (Official)

Source

microsoft/skills · .github/plugins/azure-sdk-python/skills/azure-mgmt-apimanagement-py · commit 0696600

Licence

MIT License (redistribution allowed)

LICENSE (added by AutoGineer from LICENSE)
ATTRIBUTION.md (written by AutoGineer)

Synced

2026-11-08

AutoGineer is not affiliated with or endorsed by Microsoft.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download azure-mgmt-apimanagement-py.zip