canonical: https://jentic.com/apis/azure.com/azure-notification-hubs-management

# Microsoft Azure NotificationHubsManagementClient

Jentic publishes the only available OpenAPI specification for NotificationHubsManagementClient, keeping it validated and agent-ready. The Azure Notification Hubs management API exposes 28 operations for provisioning notification hub namespaces, individual hubs, authorization rules, and platform-specific PNS credentials (APNS, GCM/FCM, WNS, MPNS, Baidu, ADM). Use it to set up the infrastructure that delivers cross-platform push notifications to mobile and desktop apps at scale, and to rotate the shared access keys that client SDKs use to register devices and send notifications.

## For AI agents

Provision Azure Notification Hubs namespaces, hubs, and PNS credentials, and manage SAS authorization rules across 28 ARM operations on the Microsoft.NotificationHubs provider.

## Scope

Does not send push notifications, manage device registrations, or handle delivery analytics - use for provisioning notification hub infrastructure and rotating SAS keys only.

## Capabilities

- Check the availability of a namespace name before creating it
- Provision notification hub namespaces with SKU and region selection
- Create individual notification hubs inside a namespace and configure platform credentials (APNS, FCM, WNS)
- Define shared access authorization rules at namespace and hub scope with Listen, Send, or Manage rights
- Rotate primary and secondary keys on authorization rules without breaking client connections
- List authorization rule connection strings for client SDK configuration
- Delete notification hubs and namespaces during teardown of staging environments

## Use cases

### Cross-Platform Push Notification Backend

Stand up the backend that delivers push notifications to an app's iOS, Android, and Windows users. Create a namespace, create one notification hub per environment (dev, staging, prod), upload APNS certificates and FCM/WNS keys, and define Listen and Send authorization rules that the mobile SDK and the application backend use respectively. Once provisioned, the actual send and registration calls happen against the data-plane endpoint, not this management API.

Example prompt: Create namespace 'app-notifications' in westeurope, create a notification hub 'production' inside it, and configure APNS production credentials and FCM credentials

### Tenant Isolation in a SaaS App

Provision a separate notification hub per customer tenant in a multi-tenant SaaS application. For each new customer signup an automation creates a hub inside a shared namespace, generates per-tenant Listen and Send authorization rules, and returns the connection strings that the tenant's mobile clients and backend will use. This isolates push registrations and audit trails per tenant without spinning up a new namespace for each one.

Example prompt: Create a new notification hub for tenant 'acme-corp' inside the shared namespace, generate Listen and Send authorization rules, and return both connection strings

### Credential Rotation and Key Management

Rotate the SAS keys on notification hub authorization rules on a fixed schedule, or in response to a suspected leak. The regenerateKeys operation rotates either the primary or secondary key on a named rule, letting an automation roll the unused key first, update clients to use the new key, then rotate the second key on the next cycle. This keeps push delivery uninterrupted while honouring rotation policy.

Example prompt: Regenerate the SecondaryKey on the DefaultFullSharedAccessSignature rule of the production hub, retrieve the new connection string, and report it back for client deployment

### AI Agent Push Notification Operator

An AI agent in a developer tools workflow can provision and rotate notification hubs through Jentic. The agent searches by intent ('create an azure notification hub'), Jentic returns the NotificationHubs_CreateOrUpdate operation with its schema, and the agent executes the call with managed Azure credentials. Hub teardown, key rotation, and credential updates run through the same intent-driven flow.

Example prompt: Search Jentic for 'create an Azure notification hub', load the NotificationHubs_CreateOrUpdate schema, and execute it for hub 'mobile-prod' with APNS credentials

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| POST | /subscriptions/{subscriptionId}/providers/Microsoft.NotificationHubs/checkNamespaceAvailability | Check if a namespace name is available |
| GET | /subscriptions/{subscriptionId}/providers/Microsoft.NotificationHubs/namespaces | List all notification hub namespaces in a subscription |
| GET | /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.NotificationHubs/namespaces | List namespaces in a resource group |
| GET | /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.NotificationHubs/namespaces/{namespaceName} | Get a notification hub namespace |
| GET | /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.NotificationHubs/namespaces/{namespaceName}/AuthorizationRules | List authorization rules on a namespace |
| POST | /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.NotificationHubs/namespaces/{namespaceName}/AuthorizationRules/{authorizationRuleName}/listKeys | List connection strings for an authorization rule |
| GET | /providers/Microsoft.NotificationHubs/operations | List Microsoft.NotificationHubs provider operations |

## Key resources

- **Namespaces** — Provision and manage notification hub namespaces
- **NotificationHubs** — Create individual notification hubs and configure PNS credentials
- **AuthorizationRules** — Define shared access rules with Listen, Send, or Manage rights and rotate their keys
- **Operations** — List Microsoft.NotificationHubs provider operations

## Why Jentic

- **Setup:** Wiring the NotificationHubsManagementClient by hand means getting an Azure AD token from login.microsoftonline.com, sending every request to management.azure.com with the right api-version, and separating namespace provisioning calls from SAS key listing calls yourself. Through Jentic you install once, import NotificationHubsManagementClient from the API Directory, store the Azure AD credential once, and your agent calls it.
- **Permission scoping:** This API carries the subscription id, resource group, and namespace name in the URL path (/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.NotificationHubs/namespaces/{namespaceName}), so a rule can pin your agent to one namespace in one resource group. You choose the operations it may call, so key-listing operations like listKeys on an authorization rule are not included unless you add them.
- **Credential handling:** Your Azure AD credential is stored once, encrypted, by your own Jentic One instance and injected at execution time. It never enters the agent's prompt, logs, or context.
- **Discovery method:** Agents search Jentic by intent such as 'create a notification hub namespace' or 'rotate notification hub keys', and Jentic returns the matching operation with its input schema so the agent calls the right endpoint without learning the Microsoft.NotificationHubs namespace.

## Related APIs

- **Azure Service Bus** — Run alongside Notification Hubs as the underlying messaging fabric for fan-out scenarios.
- **Azure Event Grid** — Event routing service useful for system-to-system push rather than mobile device push.
- **Azure IoT Hub** — Bidirectional messaging for IoT devices instead of consumer push notifications.

## FAQ

### Why is there no official OpenAPI spec for NotificationHubsManagementClient?

Microsoft Azure does not publish an OpenAPI specification. Jentic generates and maintains this spec so that AI agents and developers can call NotificationHubsManagementClient via structured tooling. It is validated against the live API and kept up to date. Get started with Jentic One, the self-hosted execution layer.

### What authentication does the Azure Notification Hubs management API use?

It uses Azure Active Directory OAuth 2.0 against https://management.azure.com/ with the user_impersonation scope. The caller needs Contributor or a custom role with Microsoft.NotificationHubs/* permissions on the resource group. Jentic stores service principal credentials encrypted and issues short-lived bearer tokens at execution time.

### Can I send a push notification through this API?

No. This is the management API for provisioning hubs and rotating keys. Actual push notification sends happen against the data-plane endpoint (https://{namespace}.servicebus.windows.net/{hub}/messages) using the SAS connection strings retrieved here, typically via the Notification Hubs SDK or REST.

### What are the rate limits for the Notification Hubs management API?

Azure Resource Manager applies subscription-level throttling at roughly 1,200 reads and 1,200 writes per hour. Hub creation and namespace creation are typically synchronous sub-second operations, so you rarely hit the limit during normal provisioning.

### How do I create a notification hub through Jentic?

Run pip install jentic and search for 'create an azure notification hub'. Jentic returns the NotificationHubs_CreateOrUpdate operation; load its schema and execute it with the namespace name, hub name, and any APNS or FCM credentials you want set at create time.

### How do I rotate a notification hub authorization key?

POST to /subscriptions/{id}/resourceGroups/{rg}/providers/Microsoft.NotificationHubs/namespaces/{ns}/AuthorizationRules/{rule}/regenerateKeys with PolicyKey set to PrimaryKey or SecondaryKey. Rotate the unused key first, update clients, then rotate the other to keep delivery uninterrupted.

### Can I limit what my agent is allowed to do with the Azure Notification Hubs Management API?

Yes. Because you run Jentic One yourself, your own rules decide which operations and credentials the agent may use. Since this API carries the subscription id, resource group, and namespace name in the URL path, a rule can pin the agent to a single namespace inside one resource group and expose only the operations you approve, such as creating or listing hubs. Sensitive calls like listing an authorization rule's connection strings stay out of reach unless you explicitly add them.