Custom Connectors

Analogy categoryAnalogies

What Custom Connectors Are For

A custom connector wraps a REST API that isn't natively supported by Power Apps or Power Automate, turning it into a first-class data source with actions, parameters, and authentication defined once. It's created either by importing an OpenAPI (Swagger) definition, importing a Postman collection, or building it manually from a blank connector.

🏏

Cricket analogy: A custom connector is like a translator hired for an overseas team — it lets Power Apps 'speak' to a proprietary API the same fluent way it already talks to Dataverse or SharePoint.

Defining a Connector from an OpenAPI Definition

An OpenAPI definition lists every endpoint as a path and HTTP method, each tagged with a unique operationId that becomes the action's callable name in Power Fx and flow designers. Request parameters and response schemas defined in the file automatically populate the connector's input and output fields, saving you from hand-configuring each one.

🏏

Cricket analogy: Defining actions with operationIds like GetPlayerStats is like naming specific overs in a bowling plan — each operationId in the OpenAPI file becomes a discrete, callable action in your connector.

yaml

paths:
  /players/{playerId}/stats:
    get:
      operationId: GetPlayerStats
      summary: Get statistics for a player
      parameters:
        - name: playerId
          in: path
          required: true
          type: string
      responses:
        '200':
          description: Player statistics
          schema:
            type: object
            properties:
              matches: { type: integer }
              average: { type: number }

Authentication Options

The Security tab supports No authentication, Basic authentication, API Key, and OAuth 2.0, each configured with the corresponding client ID, secret, or header details the backend API expects. OAuth 2.0 issues a token that is periodically refreshed automatically, whereas API Key or Basic authentication send the same static credential on every single request.

🏏

Cricket analogy: Choosing OAuth 2.0 for a connector is like a stadium's accreditation system — a player badge (token) is issued once and re-verified at each gate instead of showing ID paperwork every single time.

Use API Key for simple, low-risk internal APIs where a single shared secret is acceptable. Use OAuth 2.0 whenever the backend supports it, especially for anything exposing sensitive data, since tokens are scoped, expire, and can be revoked without changing a shared secret used everywhere.

Using a Custom Connector in Apps and Flows

Once published, a custom connector's actions are called from Power Fx with the same dot-notation syntax as any built-in connector, such as MyConnector.GetPlayerStats(playerId), and appear as a selectable action inside the Power Automate flow designer. Connectors can be shared with specific users, security groups, or the whole environment, and certified ones become available in the public Microsoft connector marketplace.

🏏

Cricket analogy: Once published, calling MyConnector.GetPlayerStats(playerId) in Power Fx is exactly like calling any built-in connector — the app doesn't know or care that it's talking to a custom API behind an adapter.

Custom connectors are almost always treated as premium, meaning every user of an app or flow calling one needs a Power Apps or Power Automate premium (or per-app) license. They also inherit any rate limits or throttling from the backend API, so design bulk operations carefully and never embed API secrets directly inside the app — rely on the connector's configured authentication instead.

Custom connectors expose any REST API as a first-class Power Apps/Power Automate data source using an OpenAPI definition or Postman collection.
Each action has a unique operationId, request parameters, and response schema that map directly to Power Fx and flow designer inputs/outputs.
Supported authentication types are No auth, Basic, API Key, and OAuth 2.0, configured on the connector's Security tab.
Custom connectors are almost always premium, requiring appropriate licensing for every user who calls them.
Connectors can be tested in the maker portal, shared with specific users/groups, and certified for the public marketplace.
Sharing a connector centrally avoids duplicating integration logic across many apps and flows.
Never hardcode API secrets inside the app itself — rely on the connector's configured authentication instead.