Copilot Studio Custom Connectors: How Philippine Enterprises Integrate AI Agents with Legacy Systems

September 24, 2026 · 10min read · The Technica Stack

Microsoft 365 Copilot works beautifully with SharePoint, Teams, and Outlook — but Philippine enterprises don't run solely on Microsoft 365. They run on:

SAP ERP deployed in 2015
Oracle Financials on-premise
Custom .NET APIs built for manufacturing workflows
Legacy SQL Server databases accessed via stored procedures
Salesforce, ServiceNow, or Zendesk for CRM and ticketing

The promise of AI agents is that users ask natural language questions and get action-oriented answers. But if Copilot cannot access your inventory system or open a support ticket in your custom helpdesk, it cannot act — it can only answer.

Custom connectors close that gap. They wrap your proprietary APIs in a low-code interface that Copilot Studio (and Microsoft 365 Copilot) can invoke, letting AI agents interact with systems that have no prebuilt integration.

Here's how Philippine enterprises are using custom connectors to make Copilot agents functionally useful — not just conversationally impressive.

What Copilot Studio Custom Connectors Are (and Aren't)

A custom connector is a wrapper around a REST API. It exposes your API's operations (GET, POST, PATCH, DELETE) as low-code actions that Copilot Studio agents can call via natural language prompts.

Example: Inventory Query

Without a connector:

User: "What's the stock level for SKU-1234?"

Copilot: "I don't have access to your inventory system. Please check your ERP directly."

With a custom connector:

User: "What's the stock level for SKU-1234?"

Copilot: [Invokes custom connector → calls GET /api/inventory/{sku} → returns data]

Copilot: "SKU-1234 has 47 units in stock at Warehouse A, 12 units at Warehouse B. Reorder threshold is 50 units — you're 9 units below threshold."

The connector translates Copilot's intent ("get stock for SKU") into an API call your system understands, then parses the response into natural language.

What Custom Connectors Are NOT

Not a replacement for APIs — your system must already expose a REST API (or you must build one). The connector wraps it; it doesn't create it.
Not real-time data replication — connectors call APIs on-demand. They do not sync data into Microsoft 365 for indexing (that's Copilot connectors for knowledge, a separate feature).
Not a code-free solution — you need API access, authentication setup, and OpenAPI schema knowledge. Low-code, not no-code.

Copilot Connectors vs Power Platform Connectors vs Custom Connectors

Microsoft has three distinct connector types, and the terminology is confusing:

Type	Purpose	When to Use
Copilot connectors (knowledge)	Index external content (ServiceNow KB, Jira, GitHub) into Microsoft Graph for semantic search	Large knowledge bases; Q&A grounding; Microsoft Search integration
Power Platform connectors (standard)	Invoke prebuilt integrations (Salesforce, Dynamics 365, SharePoint, SQL Server)	Real-time data from supported systems; actions in Power Automate/Power Apps/Copilot Studio
Custom connectors	Wrap proprietary REST APIs for systems with no prebuilt integration	Your custom ERP, legacy systems, third-party APIs without existing connectors

For Philippine enterprises: If your system is Salesforce or SAP, use a prebuilt Power Platform connector. If your system is a custom-built order management API from 2018, build a custom connector.

How Custom Connectors Work

Architecture

User → Copilot Studio Agent → Custom Connector → Your API → Database/System

User asks a question in natural language ("Check order #12345 status")
Agent recognizes intent and determines it needs order data
Agent invokes custom connector action (GetOrderStatus) configured in Copilot Studio
Connector calls your API (GET /api/orders/12345) with authentication headers
API returns JSON ({"orderId": "12345", "status": "shipped", "eta": "2026-09-26"})
Connector parses response and returns structured data to agent
Agent formats response in natural language ("Order #12345 shipped. Expected delivery: September 26.")

Authentication

Custom connectors support four auth methods:

Method	Use Case
No auth	Public APIs (rare for enterprise)
API key	Simple auth via header (`X-API-Key: <key>`)
OAuth 2.0	User-delegated auth (Salesforce, Google, Azure AD)
Basic auth	Username + password (legacy systems)

Philippine enterprises typically use OAuth 2.0 with Azure AD (when integrating Microsoft systems) or API key (for internally-hosted APIs behind firewalls).

OpenAPI Definition

Custom connectors require an OpenAPI 2.0 or 3.0 specification (formerly Swagger). This is a JSON or YAML file describing your API's endpoints, parameters, request/response schemas, and authentication.

If your API doesn't have an OpenAPI spec, you can:

Generate one from code (ASP.NET → Swashbuckle, Node.js → swagger-jsdoc)
Write one manually using Swagger Editor
Create a Postman collection and import it into Copilot Studio

Building a Custom Connector: Step-by-Step

Prerequisites

A REST API with publicly accessible or VPN-reachable endpoints
OpenAPI 2.0/3.0 definition or Postman collection
API authentication credentials (key, OAuth client ID/secret, or basic auth)
Copilot Studio license (included with Microsoft 365 Copilot or standalone Copilot Studio plan)
Power Platform environment (Developer or Sandbox recommended; default environment often has DLP restrictions)

Step 1: Prepare the OpenAPI Definition

Your OpenAPI spec must define:

Base URL (e.g., https://api.yourcompany.ph/v1)
Endpoints (e.g., /orders/{id}, /inventory/{sku})
Methods (GET, POST, PATCH, DELETE)
Parameters (path, query, body)
Responses (200 success schema, 4xx/5xx error schemas)
Authentication (security schemes)

Example: OpenAPI for a simple order lookup API

openapi: 3.0.0
info:
  title: Custom Order API
  version: 1.0.0
servers:
  - url: https://api.acmecorp.ph/v1
paths:
  /orders/{orderId}:
    get:
      summary: Get order by ID
      operationId: GetOrder
      parameters:
        - name: orderId
          in: path
          required: true
          schema:
            type: string
      responses:
        '200':
          description: Order found
          content:
            application/json:
              schema:
                type: object
                properties:
                  orderId:
                    type: string
                  status:
                    type: string
                  customerName:
                    type: string
                  total:
                    type: number
        '404':
          description: Order not found
components:
  securitySchemes:
    ApiKeyAuth:
      type: apiKey
      in: header
      name: X-API-Key
security:
  - ApiKeyAuth: []

Save this as order-api.yaml.

Step 2: Create the Custom Connector in Copilot Studio

Sign in to Copilot Studio
Select your Power Platform environment
Go to More → Discover all → Data → Custom connectors
Click + New custom connector → Import an OpenAPI file
Upload order-api.yaml
Review the General tab (connector name, host URL, description)
Go to Security tab → configure authentication type (API Key in this case)
Go to Definition tab → verify actions (operations) were imported correctly
Click Create connector

The connector is now available in Copilot Studio, Power Automate, and Power Apps within this environment.

Step 3: Test the Connector

Before integrating with an agent, test the connector in isolation:

In Power Apps or Power Automate, go to Data → Connections
Create a new connection for your custom connector
Enter the API key (or complete OAuth flow)
In Power Automate, create a test flow:
- Trigger: Manually trigger a flow
- Action: Your custom connector → GetOrder
- Input: orderId = "12345"
- Output: Display the response
Run the flow and verify the API returns expected data

If the test fails:

Check API endpoint reachability (firewall, VPN, public DNS)
Verify API key / OAuth credentials
Review OpenAPI schema vs actual API response (field names must match)

Step 4: Add the Connector to a Copilot Agent

In Copilot Studio, open your agent (or create a new one)
Go to Tools
Click + Add an action
Select Connector → choose your custom connector
Select the action you want to make available (e.g., GetOrder)
Configure the input mapping (how the agent passes parameters)
Save and publish the agent

Now when a user asks "What's the status of order 12345?", the agent can invoke the connector.

Step 5: Prompt the Agent to Use the Connector

Agents do not automatically know when to call a connector. You must train the agent via topics or declarative guidance.

Option A: Create a topic

Go to Topics → + New topic
Add trigger phrases: "check order", "order status", "where is my order"
Add a Question node to capture the order ID
Add a Call an action node → select your custom connector GetOrder
Map the captured order ID to the connector's orderId parameter
Add a Message node to display the response

Option B: Use declarative agents (advanced)

Declarative agents use natural language instructions instead of explicit topic flows:

You are a customer service agent. When a user asks about order status, use the GetOrder action to retrieve order details by order ID. Present the status, customer name, and total in a friendly summary.

The agent interprets user intent and invokes the connector without pre-defined topic flows.

Real-World Use Cases in Philippine Enterprises

Use Case 1: Manufacturing — Inventory Queries from ERP

System: Custom .NET API wrapping SQL Server inventory tables (20+ years old)

Challenge: Sales team cannot access inventory levels without logging into ERP web portal (slow, multi-step)

Solution: Custom connector wrapping inventory API endpoints

Agent capabilities:

"How many units of SKU-7890 are in stock?" → calls GET /api/inventory/{sku}
"What's the reorder threshold for product ABC?" → calls GET /api/products/{id}/reorder-settings
"Which warehouse has the most stock of SKU-1234?" → calls GET /api/inventory/{sku}/warehouses

Result: Sales team gets instant answers in Teams chat without ERP login. Average query time drops from 3 minutes (ERP login + navigation) to 8 seconds.

Use Case 2: BPO — ServiceNow Ticket Creation

System: ServiceNow IT helpdesk (cloud-hosted)

Challenge: Employees raise support tickets via email or web form; average ticket creation time is 5 minutes (navigate portal, fill fields, attach screenshot)

Solution: Prebuilt ServiceNow connector + custom connector for company-specific fields

Agent capabilities:

"Open a ticket for printer not working" → agent asks follow-up questions (location, error message) → creates ticket via connector
"What's the status of my ticket #INC0012345?" → calls ServiceNow API → returns current status, assigned agent, ETA
"Escalate my ticket to Level 2" → updates ticket priority via PATCH request

Result: Ticket creation time drops to 30 seconds. User satisfaction score increases from 3.2 to 4.5 (out of 5) due to reduced friction.

Use Case 3: Finance — Oracle Financials AP Automation

System: Oracle E-Business Suite on-premise (behind VPN)

Challenge: Approvers must log into Oracle to review and approve purchase orders; average approval cycle is 48 hours due to login delays and process friction

Solution: Custom connector exposing Oracle AP REST APIs (via Oracle REST Data Services)

Agent capabilities:

"Show me pending approvals" → calls Oracle API → returns list of POs awaiting approval
"Approve PO-5678" → calls POST /api/po/{id}/approve with approver credentials
"Reject PO-5678 with reason: vendor pricing exceeds budget" → calls reject endpoint with comment

Result: Approval cycle drops to 6 hours. Approvers act via Teams chat without Oracle login.

Technical Challenges and How to Solve Them

Challenge 1: API Behind Firewall / VPN

Problem: Enterprise APIs are often not publicly accessible. Copilot Studio connectors require reachable HTTPS endpoints.

Solution:

On-premise data gateway — install Microsoft's gateway software on a server inside your network; connectors route through it
Azure API Management — front your internal API with APIM as a public-facing proxy with rate limiting, auth, and logging
VPN + public DNS — expose API via VPN with DNS resolution (not ideal for cloud services)

Philippine enterprises typically use: Azure API Management (preferred) or on-premise gateway for legacy systems without cloud presence.

Challenge 2: Authentication Complexity

Problem: Your API uses custom auth (HMAC signatures, JWT with proprietary claims, multi-step OAuth)

Solution:

Simplify for connectors — create a connector-specific API key endpoint that wraps complex auth
Custom code in Power Automate — use Power Automate to handle auth and call API, then expose Power Automate flow as the "connector"
Azure Functions middleware — write a serverless function that handles auth and proxies requests

Most pragmatic: Create an API key–based endpoint specifically for Copilot connectors, separate from your production OAuth flow.

Challenge 3: Schema Mismatch (API Response ≠ OpenAPI Spec)

Problem: API returns { "order_id": "12345" } but OpenAPI spec says { "orderId": "12345" } (snake_case vs camelCase)

Solution:

Fix the OpenAPI spec to match actual API response (easiest)
Use Power Automate transformation — call connector in Power Automate, transform response, expose flow to agent
API versioning — create a v2 endpoint that returns camelCase specifically for connectors

Best practice: Match OpenAPI spec exactly to API reality. Any mismatch breaks the connector.

Challenge 4: Rate Limiting

Problem: Your API has strict rate limits (e.g., 100 requests/hour). Copilot agents can trigger bursts when multiple users ask simultaneously.

Solution:

Caching layer — cache frequent queries (inventory, order status) for 5-10 minutes
Connector-level throttling — configure Power Platform connector throttling limits
API quota increase — request higher limits for Copilot connector traffic

Philippine context: If your API is internally hosted, you control rate limits — set them generously for connector traffic.

Cost and Licensing

Copilot Studio Licensing

Plan	Cost (USD/month)	Message Limit	Custom Connectors
Microsoft 365 Copilot (includes Copilot Studio access)	$30 per user	Unlimited (bundled)	✅ Included
Copilot Studio standalone	$200 per tenant (25,000 messages)	25,000 / month	✅ Included
Pay-as-you-go (Azure subscription)	$0.01 per message	No cap	✅ Included

For Philippine enterprises: If you already have Microsoft 365 Copilot licenses, custom connectors are free (no additional cost). Standalone Copilot Studio is billed per message.

Power Platform Connector Licensing

Custom connectors created in Copilot Studio are shared across Power Automate and Power Apps in the same environment. If users invoke connectors from Power Automate flows, they need Power Automate licenses (per-user or per-flow).

Data Governance Considerations

Custom connectors operate under the signed-in user's identity. If a user asks Copilot to query the order API, the connector calls the API as that user (OAuth) or with a shared API key.

Security Implications

Least-privilege API access — grant connectors only the permissions they need (read-only if agents should not modify data)
Audit logging — log every connector call (user ID, timestamp, endpoint, response) for compliance
Data residency — connector traffic routes through Power Platform in your region (Southeast Asia for Philippine tenants); verify this meets data sovereignty requirements
PII handling — responses may contain personal data (customer names, addresses); ensure Copilot prompts and responses are logged per Microsoft Purview policies

Power Platform DLP Policies

Data Loss Prevention (DLP) policies in Power Platform can block custom connectors from being used in certain environments (typically the default environment).

Best practice: Create a dedicated Developer or Sandbox environment for Copilot Studio agents with custom connectors, separate from production Power Apps/Power Automate.

When NOT to Use Custom Connectors

Custom connectors are not the right tool when:

❌ Your API is unreliable (frequent downtime, long response times >10 seconds) — agents time out and users get error messages
❌ You need real-time data sync — use Copilot connectors for knowledge (index data into Microsoft Graph) instead
❌ Your API is SOAP/XML-based — connectors require REST APIs; wrap SOAP in a REST translation layer first
❌ No API exists — build an API before building a connector; connectors do not replace APIs
❌ Data is highly sensitive (payroll, confidential HR records) — consider whether Copilot should access this data at all

Getting Started: Pilot Project Checklist

For Philippine enterprises evaluating custom connectors:

Identify one high-value API (inventory, order lookup, ticket creation)
Verify API has REST endpoints and authentication method (key or OAuth)
Generate or obtain OpenAPI spec
Create custom connector in Copilot Studio (30 minutes)
Test connector in Power Automate before adding to agent
Build one-topic agent for a specific use case (e.g., "check order status")
Pilot with 5-10 users for 2 weeks
Measure adoption and time savings (queries per day, user feedback)
Expand to additional APIs if ROI is positive

Technica Solutions Inc. helps Philippine enterprises design and implement Copilot Studio custom connectors for legacy systems, SAP, Oracle, and proprietary APIs.

Our Cloud & I.T. team handles OpenAPI spec generation, Azure API Management setup, on-premise gateway installation, authentication configuration, and agent topic design — from proof-of-concept to production deployment with data governance guardrails.

We also provide Copilot adoption planning and integration roadmaps tailored to Philippine enterprise environments.

Talk to Our Cloud & I.T. Team