Unlock Power Automate: Create Custom Connectors from Scratch

Power Automate boasts hundreds of pre-built connectors, but what happens when your organization relies on custom applications, internal systems, or external APIs that lack standard integrations? This is where Custom Connectors shine. They empower Power Automate to communicate with virtually any REST API, exposing its operations as reusable actions and triggers. This low-code approach allows for seamless integration with almost any system.

What is a Custom Connector?

At its core, a Custom Connector is a wrapper around a REST API. Once created, it functions just like any standard Power Automate connector, allowing your Power Platform applications to interact with external systems without requiring users to write code within their flows. The architecture typically looks like this:

PowerAutomate ↓ CustomConnector ↓ RESTAPI ↓ ExternalApplication

Why Use a Custom Connector?

Many organizations encounter a variety of systems that could benefit from direct integration:

• Internal Applications
• Legacy Systems
• Third-Party APIs
• ERP Systems
• HR Applications
• Custom Web Services

Without a custom connector, integrating these systems often involves repeated manual API calls using HTTP actions in Power Automate. This can lead to:

• Increased development time
• Reduced reusability
• Higher maintenance overhead

Conversely, using a custom connector transforms these manual calls into reusable actions:

PowerAutomate ↓ CustomConnector ↓ ReusableActions

This significantly improves maintainability and promotes reusability across your automation efforts.

Real-World Scenario

Imagine your organization uses an Employee Management System with a REST API (e.g., https://api.contoso.com/employees). You need to perform operations like getting employee details, creating, updating, and deleting employees. Instead of configuring HTTP actions repeatedly in different flows, you can create a single custom connector for this API and reuse its actions everywhere.

Prerequisites

Before you begin building your custom connector, ensure you have the following:

• Power Automate License: Required for connector creation.
• REST API Endpoint: An accessible endpoint for the system you want to integrate with (e.g., https://api.contoso.com).
• API Documentation: Ideally, this would be in the form of a Swagger/OpenAPI definition or a Postman Collection. This is crucial for understanding the API's structure, endpoints, and parameters.
• Authentication Details: Information required to authenticate with the API, such as an API Key, Basic Authentication credentials, OAuth 2.0 flow details, or Azure AD authentication setup.

Custom Connector Architecture

The custom connector acts as the bridge between the Power Platform and your external systems. The flow is as follows:

ExternalAPI ↓ Authentication ↓ CustomConnector ↓ PowerAutomate ↓ BusinessProcess

Step-by-Step Guide to Creating a Custom Connector

Step 1: Open Power Automate

Navigate to make.powerautomate.com. In the left-hand navigation pane, select More, then Discover all, and finally Custom connectors.

Click on + New custom connector.

Step 2: Choose Creation Method

You have several options for creating your connector:

• Create from blank: Build the connector manually, step by step.
• Import an OpenAPI file: Use a Swagger definition to automatically generate the connector structure.
• Import a Postman collection: Generate the connector from a Postman collection.
• Import from Azure: Connect to Azure-hosted APIs.

For this tutorial, we will select Create from blank.

Step 3: Configure General Information

In this section, you'll provide basic details about your connector:

• Connector Name: A descriptive name (e.g., EmployeeManagementAPI).
• Description: A brief explanation of the connector's purpose (e.g., Employee Integration Connector).
• Host: The domain name of your API (e.g., api.contoso.com).
• Base URL: The prefix for all API paths (e.g., /employee).

The full URL will be constructed as Host + Base URL (e.g., https://api.contoso.com/employee).

Step 4: Configure Authentication

Select the authentication type required by your API. Common options include:

• No Authentication: For public APIs.
• API Key: A common method where a key is passed in the header or query string.
• Basic Authentication: Uses a username and password.
• OAuth 2.0: For enterprise APIs requiring more complex authorization flows.
• Azure Active Directory: For integrating with Microsoft services.

For our example, let's assume API Key authentication. You'll need to specify the Parameter (e.g., x-api-key) and its Location (e.g., Header).

Step 5: Define API Actions (Get Employee)

Navigate to the Definition tab and click Add action. Actions represent the operations your connector can perform.

• Summary: A user-friendly name for the action (e.g., RetrieveEmployeeInformation).
• Operation ID: A unique identifier for the action (e.g., GetEmployee).

Configure Request:

• Method: Select the HTTP method (e.g., GET).
• URL: Define the endpoint path (e.g., /employees/{id}). The {id} signifies a path parameter.
• Parameters: Add the path parameter id. You can set its type (e.g., integer) and provide an example value (e.g., 123).

Configure Response:

• Provide a Sample Response JSON object that represents the expected output from the API. For example:

  {
    "id":123,
    "name":"John Smith",
    "department":"IT",
    "email":"john@contoso.com"
  }

Clicking Import after providing the sample response will automatically generate the output fields for Power Automate.

Step 6: Add Create Employee Action

Add another action for creating an employee:

• Summary: CreateNewEmployee
• Operation ID: CreateEmployee
• Method: POST
• Endpoint: /employees
• Request Body: Define the JSON structure for the new employee record:

  {
    "name":"John Smith",
    "department":"IT",
    "email":"john@contoso.com"
  }

This action will create a new employee record in your system.

Step 7: Add Update Employee Action

Add an action to update an existing employee:

• Summary: UpdateEmployeeDetails
• Operation ID: UpdateEmployee
• Method: PUT
• Endpoint: /employees/{id}
• Request Body: Define the JSON structure for the update, specifying which fields can be modified:

  {
    "department":"Finance"
  }

This action allows you to update specific details of an employee.

Step 8: Add Delete Employee Action

Add an action to delete an employee:

• Summary: RemoveEmployee
• Operation ID: DeleteEmployee
• Method: DELETE
• Endpoint: /employees/{id}

This action will delete the selected employee record.

Step 9: Test the Connector

Navigate to the Test tab. You'll need to create a connection first by providing the necessary authentication details (e.g., your API Key).

Once the connection is established, select an operation (e.g., GetEmployee), provide the required parameters (e.g., EmployeeID=123), and click Test operation.

Review the Response to ensure it matches your expectations. A successful response for GetEmployee might look like:

{
  "id":123,
  "name":"John Smith"
}

Step 10: Publish Connector

Once you are satisfied with the testing, click Update connector or Publish. Your custom connector will now be available for use in Power Automate, Power Apps, and Azure Logic Apps.

Using Your Connector in Power Automate

In Power Automate, when building a flow, you can now search for and select your custom connector just like any standard connector. For example, a flow could be triggered manually, then use your GetEmployee action, followed by a CreateApproval action, and finally a SendEmail action.

Instead of using generic HTTP actions, you select your specific connector actions, making your flows more readable and maintainable. This is invaluable for business processes like employee onboarding, where you might trigger a flow when an employee is created, use the custom connector to RetrieveEmployeeDetails, create a record in CRM, and then send a welcome email.

Advanced Features

Custom connectors offer several advanced capabilities:

• Dynamic Parameters: Allow parameters to be populated based on previous steps or user input.
• Custom Headers: Support for specific API header requirements.
• Multiple Actions: Expose all necessary endpoints from your API.
• Triggers: Enable event-driven automations (though this is more complex and often requires webhooks).
• Error Handling: Define custom error messages and responses.

Common Authentication Methods Recap

• API Key: Ideal for public or simpler APIs.
• Basic Authentication: Suitable for legacy systems with username/password access.
• OAuth 2.0: Robust security for enterprise applications.
• Azure AD: Seamless integration with Microsoft ecosystem services.
• No Auth: For completely public services.

Benefits of Custom Connectors

• Reusable Integration: Build once, use everywhere.
• Low-Code Development: Empowers citizen developers and speeds up development.
• Centralized API Management: Manage all external API interactions in one place.
• Better User Experience: Actions appear as familiar, standard connector operations.
• Secure Authentication: Supports enterprise-grade security protocols.

Common Use Cases

• ERP Integration: Connect to SAP, Oracle, or custom ERP systems.
• HR Systems: Manage employee information and workflows.
• CRM Integrations: Exchange customer data with various CRM platforms.
• Finance Applications: Automate invoice processing and financial reporting.
• Internal Applications: Expose custom business functions and data.

Best Practices

• Use OpenAPI Specifications: Simplifies and standardizes connector creation.
• Secure Authentication: Never expose credentials directly; use secure methods like OAuth 2.0 or Azure AD.
• Document Endpoints: Maintain clear documentation for all API operations.
• Use Meaningful Action Names: Improve usability for flow creators.
• Test Thoroughly: Validate all operations, including edge cases and error handling.
• Version Control: Plan for and manage connector updates carefully.

Real-World Example: Inventory Management

Consider a company with a custom Inventory Management System. Instead of embedding HTTP requests for GetProductStock across multiple Power Automate flows, they can create an Inventory Connector. This connector provides a reusable GetStock action, offering consistent and efficient access to inventory data across the organization.

Conclusion

Custom Connectors are a cornerstone of Power Automate's integration capabilities. They bridge the gap between the Power Platform and any REST API, offering a low-code solution for complex integrations. Whether you're connecting ERP systems, HR platforms, CRMs, or custom web services, a well-designed Custom Connector can significantly simplify integrations, enhance reusability, and accelerate automation development across your organization.