0
# API Management
1

2
Comprehensive API lifecycle management including API creation, versioning, revisions, operations, schemas, policies, and export/import capabilities. Supports REST, SOAP, GraphQL, and WebSocket APIs with full OpenAPI specification support.
3

4
## Capabilities
5

6
### Core API Operations
7

8
Fundamental API management operations for creating, reading, updating, and deleting APIs within API Management services.
9

10
```python { .api }
11
class ApiOperations:
12
    def get(self, resource_group_name: str, service_name: str, api_id: str, **kwargs) -> ApiContract: ...
13
    def begin_create_or_update(self, resource_group_name: str, service_name: str, api_id: str, parameters: ApiCreateOrUpdateParameter, if_match: Optional[str] = None, **kwargs) -> LROPoller[ApiContract]: ...
14
    def begin_update(self, resource_group_name: str, service_name: str, api_id: str, if_match: str, parameters: ApiUpdateContract, **kwargs) -> LROPoller[ApiContract]: ...
15
    def delete(self, resource_group_name: str, service_name: str, api_id: str, if_match: str, delete_revisions: Optional[bool] = None, **kwargs) -> None: ...
16
    def list_by_service(self, resource_group_name: str, service_name: str, filter: Optional[str] = None, top: Optional[int] = None, skip: Optional[int] = None, tags: Optional[str] = None, expand_api_version_set: Optional[bool] = None, **kwargs) -> ItemPaged[ApiContract]: ...
17
    def get_entity_tag(self, resource_group_name: str, service_name: str, api_id: str, **kwargs) -> bool: ...
18
```
19

20
### API Revision Management
21

22
API revision system for managing different versions of APIs during development and deployment cycles.
23

24
```python { .api }
25
class ApiRevisionOperations:
26
    def list_by_service(self, resource_group_name: str, service_name: str, api_id: str, filter: Optional[str] = None, top: Optional[int] = None, skip: Optional[int] = None, **kwargs) -> ItemPaged[ApiRevisionContract]: ...
27
```
28

29
### API Release Management
30

31
API release management for promoting API revisions to production and managing release cycles.
32

33
```python { .api }
34
class ApiReleaseOperations:
35
    def get(self, resource_group_name: str, service_name: str, api_id: str, release_id: str, **kwargs) -> ApiReleaseContract: ...
36
    def begin_create_or_update(self, resource_group_name: str, service_name: str, api_id: str, release_id: str, parameters: ApiReleaseContract, if_match: Optional[str] = None, **kwargs) -> LROPoller[ApiReleaseContract]: ...
37
    def begin_update(self, resource_group_name: str, service_name: str, api_id: str, release_id: str, if_match: str, parameters: ApiReleaseContract, **kwargs) -> LROPoller[ApiReleaseContract]: ...
38
    def delete(self, resource_group_name: str, service_name: str, api_id: str, release_id: str, if_match: str, **kwargs) -> None: ...
39
    def list_by_service(self, resource_group_name: str, service_name: str, api_id: str, filter: Optional[str] = None, top: Optional[int] = None, skip: Optional[int] = None, **kwargs) -> ItemPaged[ApiReleaseContract]: ...
40
    def get_entity_tag(self, resource_group_name: str, service_name: str, api_id: str, release_id: str, **kwargs) -> bool: ...
41
```
42

43
### API Operation Management
44

45
Management of individual operations (endpoints) within APIs, including operation-specific policies and configurations.
46

47
```python { .api }
48
class ApiOperationOperations:
49
    def get(self, resource_group_name: str, service_name: str, api_id: str, operation_id: str, **kwargs) -> OperationContract: ...
50
    def begin_create_or_update(self, resource_group_name: str, service_name: str, api_id: str, operation_id: str, parameters: OperationContract, if_match: Optional[str] = None, **kwargs) -> LROPoller[OperationContract]: ...
51
    def begin_update(self, resource_group_name: str, service_name: str, api_id: str, operation_id: str, if_match: str, parameters: OperationUpdateContract, **kwargs) -> LROPoller[OperationContract]: ...
52
    def delete(self, resource_group_name: str, service_name: str, api_id: str, operation_id: str, if_match: str, **kwargs) -> None: ...
53
    def list_by_api(self, resource_group_name: str, service_name: str, api_id: str, filter: Optional[str] = None, top: Optional[int] = None, skip: Optional[int] = None, tags: Optional[str] = None, **kwargs) -> ItemPaged[OperationContract]: ...
54
    def get_entity_tag(self, resource_group_name: str, service_name: str, api_id: str, operation_id: str, **kwargs) -> bool: ...
55
```
56

57
### API Schema Management
58

59
Schema management for API documentation and validation, supporting OpenAPI, JSON Schema, and other schema formats.
60

61
```python { .api }
62
class ApiSchemaOperations:
63
    def get(self, resource_group_name: str, service_name: str, api_id: str, schema_id: str, **kwargs) -> SchemaContract: ...
64
    def begin_create_or_update(self, resource_group_name: str, service_name: str, api_id: str, schema_id: str, parameters: SchemaContract, if_match: Optional[str] = None, **kwargs) -> LROPoller[SchemaContract]: ...
65
    def delete(self, resource_group_name: str, service_name: str, api_id: str, schema_id: str, if_match: str, force: Optional[bool] = None, **kwargs) -> None: ...
66
    def list_by_api(self, resource_group_name: str, service_name: str, api_id: str, filter: Optional[str] = None, top: Optional[int] = None, skip: Optional[int] = None, **kwargs) -> ItemPaged[SchemaContract]: ...
67
    def get_entity_tag(self, resource_group_name: str, service_name: str, api_id: str, schema_id: str, **kwargs) -> bool: ...
68
```
69

70
### API Policy Management
71

72
API-level policy management for implementing cross-cutting concerns like authentication, rate limiting, and transformations.
73

74
```python { .api }
75
class ApiPolicyOperations:
76
    def get(self, resource_group_name: str, service_name: str, api_id: str, policy_id: str, format: Optional[str] = None, **kwargs) -> PolicyContract: ...
77
    def create_or_update(self, resource_group_name: str, service_name: str, api_id: str, policy_id: str, parameters: PolicyContract, if_match: Optional[str] = None, **kwargs) -> PolicyContract: ...
78
    def delete(self, resource_group_name: str, service_name: str, api_id: str, policy_id: str, if_match: str, **kwargs) -> None: ...
79
    def list_by_api(self, resource_group_name: str, service_name: str, api_id: str, **kwargs) -> PolicyCollection: ...
80
    def get_entity_tag(self, resource_group_name: str, service_name: str, api_id: str, policy_id: str, **kwargs) -> bool: ...
81
```
82

83
### API Export and Import
84

85
Export APIs to various formats (OpenAPI, WADL, WSDL) and import APIs from external sources.
86

87
```python { .api }
88
class ApiExportOperations:
89
    def get(self, resource_group_name: str, service_name: str, api_id: str, format_param: str, export_param: str, **kwargs) -> ApiExportResult: ...
90
```
91

92
### API Version Set Management
93

94
Management of API version sets for organizing and versioning related APIs.
95

96
```python { .api }
97
class ApiVersionSetOperations:
98
    def get(self, resource_group_name: str, service_name: str, version_set_id: str, **kwargs) -> ApiVersionSetContract: ...
99
    def begin_create_or_update(self, resource_group_name: str, service_name: str, version_set_id: str, parameters: ApiVersionSetContract, if_match: Optional[str] = None, **kwargs) -> LROPoller[ApiVersionSetContract]: ...
100
    def begin_update(self, resource_group_name: str, service_name: str, version_set_id: str, if_match: str, parameters: ApiVersionSetUpdateParameters, **kwargs) -> LROPoller[ApiVersionSetContract]: ...
101
    def delete(self, resource_group_name: str, service_name: str, version_set_id: str, if_match: str, **kwargs) -> None: ...
102
    def list_by_service(self, resource_group_name: str, service_name: str, filter: Optional[str] = None, top: Optional[int] = None, skip: Optional[int] = None, **kwargs) -> ItemPaged[ApiVersionSetContract]: ...
103
    def get_entity_tag(self, resource_group_name: str, service_name: str, version_set_id: str, **kwargs) -> bool: ...
104
```
105

106
### API Documentation Management
107

108
Wiki and documentation management for APIs.
109

110
```python { .api }
111
class ApiWikiOperations:
112
    def get(self, resource_group_name: str, service_name: str, api_id: str, **kwargs) -> WikiContract: ...
113
    def begin_create_or_update(self, resource_group_name: str, service_name: str, api_id: str, parameters: WikiContract, if_match: Optional[str] = None, **kwargs) -> LROPoller[WikiContract]: ...
114
    def begin_update(self, resource_group_name: str, service_name: str, api_id: str, if_match: str, parameters: WikiUpdateContract, **kwargs) -> LROPoller[WikiContract]: ...
115
    def delete(self, resource_group_name: str, service_name: str, api_id: str, if_match: str, **kwargs) -> None: ...
116
    def get_entity_tag(self, resource_group_name: str, service_name: str, api_id: str, **kwargs) -> bool: ...
117
```
118

119
### GraphQL API Support
120

121
Specialized operations for GraphQL API management including resolver and policy management.
122

123
```python { .api }
124
class GraphQLApiResolverOperations:
125
    def get(self, resource_group_name: str, service_name: str, api_id: str, resolver_id: str, **kwargs) -> ResolverContract: ...
126
    def begin_create_or_update(self, resource_group_name: str, service_name: str, api_id: str, resolver_id: str, parameters: ResolverContract, if_match: Optional[str] = None, **kwargs) -> LROPoller[ResolverContract]: ...
127
    def begin_update(self, resource_group_name: str, service_name: str, api_id: str, resolver_id: str, if_match: str, parameters: ResolverUpdateContract, **kwargs) -> LROPoller[ResolverContract]: ...
128
    def delete(self, resource_group_name: str, service_name: str, api_id: str, resolver_id: str, if_match: str, **kwargs) -> None: ...
129
    def list_by_api(self, resource_group_name: str, service_name: str, api_id: str, filter: Optional[str] = None, top: Optional[int] = None, skip: Optional[int] = None, **kwargs) -> ItemPaged[ResolverContract]: ...
130
    def get_entity_tag(self, resource_group_name: str, service_name: str, api_id: str, resolver_id: str, **kwargs) -> bool: ...
131

132
class GraphQLApiResolverPolicyOperations:
133
    def get(self, resource_group_name: str, service_name: str, api_id: str, resolver_id: str, policy_id: str, format: Optional[str] = None, **kwargs) -> PolicyContract: ...
134
    def create_or_update(self, resource_group_name: str, service_name: str, api_id: str, resolver_id: str, policy_id: str, parameters: PolicyContract, if_match: Optional[str] = None, **kwargs) -> PolicyContract: ...
135
    def delete(self, resource_group_name: str, service_name: str, api_id: str, resolver_id: str, policy_id: str, if_match: str, **kwargs) -> None: ...
136
    def list_by_resolver(self, resource_group_name: str, service_name: str, api_id: str, resolver_id: str, **kwargs) -> PolicyCollection: ...
137
    def get_entity_tag(self, resource_group_name: str, service_name: str, api_id: str, resolver_id: str, policy_id: str, **kwargs) -> bool: ...
138
```
139

140
## Usage Examples
141

142
### Creating a New API
143

144
```python
145
from azure.mgmt.apimanagement.models import ApiCreateOrUpdateParameter, ApiType, Protocol
146

147
# Create API from OpenAPI specification
148
api_params = ApiCreateOrUpdateParameter(
149
    display_name="Pet Store API",
150
    service_url="https://petstore.swagger.io/v2",
151
    path="petstore",
152
    protocols=[Protocol.HTTPS],
153
    api_type=ApiType.HTTP,
154
    format="openapi+json",
155
    value="https://petstore.swagger.io/v2/swagger.json"  # OpenAPI spec URL
156
)
157

158
# Create the API
159
api = client.api.begin_create_or_update(
160
    resource_group_name="my-rg",
161
    service_name="my-apim",
162
    api_id="petstore-api",
163
    parameters=api_params
164
).result()
165

166
print(f"Created API: {api.display_name}")
167
```
168

169
### Managing API Versions
170

171
```python
172
from azure.mgmt.apimanagement.models import ApiVersionSetContract, VersioningScheme
173

174
# Create version set
175
version_set = ApiVersionSetContract(
176
    display_name="Pet Store API Versions",
177
    versioning_scheme=VersioningScheme.SEGMENT,
178
    version_query_name="version",
179
    description="Versions of the Pet Store API"
180
)
181

182
version_set = client.api_version_set.begin_create_or_update(
183
    resource_group_name="my-rg",
184
    service_name="my-apim",
185
    version_set_id="petstore-versions",
186
    parameters=version_set
187
).result()
188

189
# Create versioned API
190
api_v2_params = ApiCreateOrUpdateParameter(
191
    display_name="Pet Store API v2",
192
    service_url="https://petstore.swagger.io/v2",
193
    path="petstore",
194
    api_version="v2",
195
    api_version_set_id=version_set.id,
196
    protocols=[Protocol.HTTPS]
197
)
198

199
api_v2 = client.api.begin_create_or_update(
200
    resource_group_name="my-rg",
201
    service_name="my-apim",
202
    api_id="petstore-api-v2",
203
    parameters=api_v2_params
204
).result()
205
```
206

207
### Working with API Operations
208

209
```python
210
from azure.mgmt.apimanagement.models import OperationContract, RequestContract, ResponseContract
211

212
# Create a new operation
213
operation = OperationContract(
214
    display_name="Get Pet by ID",
215
    method="GET",
216
    url_template="/pet/{petId}",
217
    template_parameters=[
218
        ParameterContract(
219
            name="petId",
220
            type="integer",
221
            required=True,
222
            description="ID of pet to return"
223
        )
224
    ],
225
    responses=[
226
        ResponseContract(
227
            status_code=200,
228
            description="Successful operation",
229
            representations=[
230
                RepresentationContract(
231
                    content_type="application/json"
232
                )
233
            ]
234
        ),
235
        ResponseContract(
236
            status_code=404,
237
            description="Pet not found"
238
        )
239
    ]
240
)
241

242
# Add operation to API
243
operation = client.api_operation.begin_create_or_update(
244
    resource_group_name="my-rg",
245
    service_name="my-apim",
246
    api_id="petstore-api",
247
    operation_id="get-pet-by-id",
248
    parameters=operation
249
).result()
250
```
251

252
## Types
253

254
### Core API Types
255

256
```python { .api }
257
class ApiContract:
258
    id: Optional[str]
259
    name: Optional[str]
260
    type: Optional[str]
261
    properties: Optional[ApiContractProperties]
262

263
class ApiCreateOrUpdateParameter:
264
    properties: Optional[ApiCreateOrUpdateProperties]
265

266
class ApiContractProperties:
267
    display_name: Optional[str]
268
    service_url: Optional[str]
269
    path: Optional[str]
270
    protocols: Optional[List[Protocol]]
271
    api_version: Optional[str]
272
    api_version_description: Optional[str]
273
    api_version_set_id: Optional[str]
274
    subscription_required: Optional[bool]
275
    subscription_key_parameter_names: Optional[SubscriptionKeyParameterNamesContract]
276
    api_type: Optional[ApiType]
277
    api_revision: Optional[str]
278
    api_revision_description: Optional[str]
279
    source_api_id: Optional[str]
280
    is_current: Optional[bool]
281
    is_online: Optional[bool]
282
    description: Optional[str]
283
    authentication_settings: Optional[AuthenticationSettingsContract]
284
    contact: Optional[ApiContactInformation]
285
    license: Optional[ApiLicenseInformation]
286
    terms_of_service_url: Optional[str]
287

288
class OperationContract:
289
    id: Optional[str]
290
    name: Optional[str]
291
    type: Optional[str]
292
    properties: Optional[OperationContractProperties]
293

294
class OperationContractProperties:
295
    display_name: Optional[str]
296
    method: Optional[str]
297
    url_template: Optional[str]
298
    template_parameters: Optional[List[ParameterContract]]
299
    description: Optional[str]
300
    request: Optional[RequestContract]
301
    responses: Optional[List[ResponseContract]]
302
    policies: Optional[str]
303
```
304

305
### API Enums
306

307
```python { .api }
308
class ApiType:
309
    HTTP = "http"
310
    SOAP = "soap"
311
    WEBSOCKET = "websocket"
312
    GRAPHQL = "graphql"
313

314
class Protocol:
315
    HTTP = "http"
316
    HTTPS = "https"
317
    WS = "ws"
318
    WSS = "wss"
319

320
class ContentFormat:
321
    WADL_XML = "wadl-xml"
322
    WADL_LINK_JSON = "wadl-link-json"
323
    SWAGGER_JSON = "swagger-json"
324
    SWAGGER_LINK_JSON = "swagger-link-json"
325
    WSDL = "wsdl"
326
    WSDL_LINK = "wsdl-link"
327
    OPENAPI = "openapi"
328
    OPENAPI_JSON = "openapi+json"
329
    OPENAPI_LINK = "openapi-link"
330
    OPENAPI_JSON_LINK = "openapi+json-link"
331
    GRAPHQL_LINK = "graphql-link"
332

333
class VersioningScheme:
334
    SEGMENT = "Segment"
335
    QUERY = "Query"
336
    HEADER = "Header"
337

338
class SoapApiType:
339
    SOAP_TO_REST = "SoapToRest"
340
    SOAP_PASS_THROUGH = "SoapPassThrough"
341
```