Study guide

6.3 Importing Definitions and Creating Connectors for Azure Services

Microsoft Power Platform Developer Associate PL-400

Track your progress as you read

Finished sections get a check mark.

1 Introduction, Exam Overview & Developer Toolchain

0.1 PL-400 Exam Facts 0.2 Audience Profile & Required Developer Skills 0.3 The Power Platform Developer Toolchain 0.4 Extension-Point Map & AI in the Developer Workflow

2 Create a Technical Design

1.1 Analyzing Technical Architecture and Choosing Out-of-the-Box vs. Custom Solutions 1.2 Designing Authentication, Authorization, and Security Architecture 1.3 Deciding Where Business Logic Runs and Choosing the Right Table Type 1.4 Designing Reusable Power Apps Components and Custom Connectors 1.5 Designing Dataverse Code Components, Automations, and Integrations

3 Build Power Platform Solutions

2.1 Managing Power Platform Environments for Development 2.2 Dataverse Security Roles for Code Components, Least Privilege & Troubleshooting Operational Security 2.3 Solutions, Managing Dependencies & Solution Layers 2.4 Environment Variables & Connection References 2.5 Power Platform Pipelines & CI/CD with Power Platform Build Tools

4 Implement Power Apps Improvements

3.1 Complex Power Fx Formulas and Functions 3.2 Building Reusable Canvas Component Libraries 3.3 Invoking Power Automate Cloud Flows from a Canvas App 3.4 Troubleshooting Canvas and Model-Driven Apps with Monitor and Browser Debugging Tools 3.5 Optimizing Canvas and Model-Driven App Performance

5 Extend the User Experience

4.1 The Client API Object Model & JavaScript Form Scripting 4.2 Event Handler Registration & Navigation to Custom Pages via the Client API 4.3 Client Scripting Against the Dataverse Web API; Command Bar & Buttons with Power Fx and JavaScript 4.4 PCF Fundamentals: The Component Manifest & Lifecycle Events 4.5 Implementing PCF Component Interfaces; Device, Utility & Web API Features 4.6 Packaging, Deploying & Consuming a PCF Component

6 Extend the Platform: Dataverse Plug-ins & Custom APIs

5.1 Plug-in Fundamentals & the Event Execution Pipeline Stages 5.2 Execution Context & Implementing Business Logic in Plug-ins 5.3 Pre/Post Images & Organization Service Operations in Plug-ins 5.4 Registering Plug-ins with the Plug-in Registration Tool & Optimizing Plug-in Performance 5.5 Custom API Messages & Plug-ins That Implement a Custom API 5.6 Configuring Dataverse Business Events

7 Extend the Platform: Custom Connectors

6.1 Open API Definitions: Building and Extending a Custom Connector 6.2 Authentication and Policy Templates for Custom Connectors 6.3 Importing Definitions and Creating Connectors for Azure Services 6.4 Azure Functions in Custom Connectors and Data Transformation

8 Extend the Platform: Platform APIs & Azure Functions

7.1 Dataverse Web API Operations & OAuth Authentication 7.2 Organization Service Operations, Concurrency, Transactions & Bulk Operations 7.3 Service Protection API Limits & Retry Policies 7.4 Azure Functions for Long-Running, Scheduled & Event-Driven Workloads 7.5 Authenticating to Power Platform with Managed Identities

9 Extend the Platform: Power Automate Cloud Flows

8.1 Dataverse connector triggers/actions, trigger filters & retry policies 8.2 Complex expressions & flow control with error handling 8.3 Sensitive input/output parameters & Azure Key Vault 8.4 Reusable child flows & Microsoft Entra ID service principals

10 Develop Integrations

9.1 Publishing Dataverse Events: IServiceEndpointNotificationService & the Plug-in Registration Tool 9.2 Registering Service Endpoints: Webhooks, Azure Service Bus & Event Hub 9.3 Data Synchronization with Change Tracking & Alternate Keys 9.4 Upsert-Based Synchronization with the UpsertRequest Message

11 Exam Readiness & Practice

10.1 Cross-Domain "Where Do I Implement This?" Decision Framework 10.2 Exam-Day Strategy, PL-400 Item Styles & Study Plan

6.3 Importing Definitions and Creating Connectors for Azure Services

Key Takeaways Explain This Topic AI

Custom connectors can be created by importing an OpenAPI file or URL, importing a Postman collection, cloning a definition from the PowerPlatformConnectors GitHub repository, or creating directly from an Azure service.

Create from Azure service lists resources in a connected subscription — commonly Azure Functions, Logic Apps, and API Apps — and auto-populates host, base URL, and security from exposed Swagger metadata.

Postman collection imports are request-centric, so descriptions, required/optional flags, and response schemas typically need manual cleanup afterward.

Pulling a definition from GitHub gives a developer an editable, owned starting point, unlike simply installing a locked, Microsoft-maintained certified connector.

Every import path still passes through the same General/Security/Definition/Test wizard; importing only pre-fills those tabs.

Last updated: July 2026

A custom connector rarely needs to be built entirely from scratch. PL-400 expects familiarity with three additional entry points for creating a connector from an existing definition, plus the dedicated path for wrapping an Azure-hosted service.

Importing an Open API Definition

If the target API already publishes a Swagger 2.0 or OpenAPI 3.x document, the fastest path is Custom connectors > + New custom connector > Import an OpenAPI file (or Import an OpenAPI from URL ). The wizard reads the paths , parameters, and schemas straight from the document and pre-populates the Definition tab's actions, so the developer's job shifts from authoring definitions to reviewing and refining them — adding x-ms-summary labels, tightening required fields, and configuring authentication, since OpenAPI documents do not always carry the security details a connector needs.

Importing from GitHub

Microsoft publishes the source for every certified connector — including the OpenAPI definitions Microsoft itself maintains for first-party services — in the public PowerPlatformConnectors GitHub repository. A developer can pull a connector's apiDefinition.swagger.json (and its accompanying apiProperties.json , which carries the authentication configuration) from that repository as a starting point, then modify it for a custom scenario — for example, cloning an existing connector's structure to build a similar one against an internal API, or forking a certified connector's definition to add a custom operation. This is distinct from simply installing a certified connector: pulling from GitHub gives you an editable definition you own and can extend, rather than a locked, Microsoft-maintained connector.

Importing a Postman Collection

For APIs that only have a Postman collection (exported from Postman as a v1-format collection file) rather than a formal OpenAPI document, the Import a Postman collection option converts each saved request into a connector action, inferring the verb, path, headers, and body from the collection. Because Postman collections are request-centric rather than schema-centric, the resulting connector definitions are usually rougher than an OpenAPI import — parameter descriptions, required/optional flags, and response schemas typically need manual cleanup afterward in the Definition tab or Swagger editor.

Creating a Custom Connector for an Azure Service

A dedicated fourth path exists specifically for Azure-hosted services : + New custom connector > Create from Azure service . This flow lists the Azure resources available in a connected subscription — commonly Azure Functions , Logic Apps , and API Apps — and, when the selected resource exposes Swagger/OpenAPI metadata (as an Azure Function App does when it has a Swagger extension enabled, or an API Management–fronted API does natively), auto-populates the connector's host, base URL, and even its security scheme directly from that resource.

This matters most for Azure Functions, because it is the single most common backing service for a custom connector built during PL-400-style solution work:

If the Function App is secured with a function key , the wizard can configure an API Key authentication type that automatically supplies the key as a header or query parameter on every call.

If the Function App is secured with Microsoft Entra ID , the wizard configures OAuth 2.0 authentication against the app registration protecting the function, so the connector inherits the same identity-based security as the function itself.

  • Import path Best when…
  • OpenAPI file/URL The API already has a maintained Swagger/OpenAPI document
  • GitHub (PowerPlatformConnectors) Cloning or extending an existing Microsoft-maintained connector's definition
  • Postman collection Only ad-hoc request examples exist, no formal API spec

Create from Azure service The backing service is an Azure Function App, Logic App, or API App in a connected subscription

Regardless of import path, the resulting connector still passes through the same General / Security / Definition / Test wizard — importing just pre-fills those tabs rather than replacing the workflow.

Sharing and Certifying a Connector

A newly created custom connector is, by default, visible only to its owner within the environment it was created in. Two mechanisms extend that reach:

Sharing — from the connector's Share tab, the owner can add individual users or an Entra ID security group as co-owners , letting them see, use, and edit the connector, similarly to sharing any other Power Platform component. This is the normal path for making a connector usable by the rest of a development team or by makers building apps and flows in the same environment.

Microsoft certification — to make a connector available tenant-wide by default, or publicly to all Power Platform customers , a developer submits it through Microsoft's connector certification process, which involves opening a pull request against the public PowerPlatformConnectors GitHub repository with the connector's OpenAPI definition and metadata. Certification requires meeting Microsoft's published requirements — a valid support contact, terms of use, a compliant icon, a working authentication flow, and a security review — after which the connector is published as a standard, first-party-style entry in the global connector list rather than something each environment has to import individually.

Sharing is the everyday mechanism for team collaboration; certification is reserved for connectors intended to be reused broadly outside a single organization.