canonical: https://jentic.com/apis/azure.com/azure-data-factory-management

# Microsoft Azure DataFactoryManagementClient

Jentic publishes the only available OpenAPI specification for DataFactoryManagementClient, keeping it validated and agent-ready. The Azure Data Factory management API exposes 76 operations across 58 paths to provision factories and manage every artefact inside them: linked services, datasets, pipelines, triggers, integration runtimes, data flows, and debug sessions. Use it to stand up a new Data Factory, configure source-control integration, register linked services for source and sink stores, define and run pipelines, and operate self-hosted or Azure-hosted integration runtimes for hybrid ETL.

## For AI agents

Provision Azure Data Factory factories and manage their pipelines, datasets, linked services, triggers, integration runtimes, and data flow debug sessions through 76 ARM operations.

## Scope

Does not move or transform data itself, host pipeline compute, or query lineage - use for managing Data Factory instances and their authoring artefacts only.

## Capabilities

- Create and configure Data Factory instances with optional source-control (Git) integration
- Manage linked services that hold connection details for source and sink stores
- Define datasets, pipelines, triggers, and data flows that compose ETL workflows
- Provision and operate self-hosted and Azure-hosted integration runtimes for hybrid data movement
- Start, stop, and inspect data flow debug sessions for in-development pipelines
- Configure factory-level repository settings via configureFactoryRepo
- Query exposure-control feature values to gate preview features at factory level

## Use cases

### Provision a Data Factory with Git Integration

Create a Data Factory configured with a GitHub or Azure DevOps repository so all subsequent linked services, datasets, and pipelines are version-controlled. The Factories_CreateOrUpdate endpoint accepts a repoConfiguration block that points to the repo URL, branch, and root folder. Once configured, factory artefacts are saved to Git on edit and can be promoted across environments via standard pull request workflows.

Example prompt: Create a Data Factory named 'adf-prod' in resource group 'rg-data' with Azure DevOps repo configuration pointing to project 'data-platform' branch 'main'

### Hybrid ETL with Self-Hosted Integration Runtimes

Provision a self-hosted integration runtime on a factory to move data from on-premises sources (SQL Server, file shares, network-isolated APIs) into Azure stores. The IntegrationRuntimes endpoints handle creation, key retrieval for installer registration, and status checks. Pair with linked services that reference the runtime so pipelines route their connections through the on-premises agent.

Example prompt: Create a self-hosted integration runtime named 'on-prem-ir' on factory 'adf-prod' and return its authentication keys for installer registration

### Data Flow Debug Session Lifecycle

Start, attach, and stop data flow debug sessions to validate Mapping Data Flows during development. The DataFlowDebugSession endpoints create a session, add data flow definitions to it, and execute commands against the session. This is the same flow the Data Factory UI uses, so automation can build CI checks that exercise data flows before deployment.

Example prompt: Create a data flow debug session on factory 'adf-prod', add a Mapping Data Flow definition, and report the session ID and cluster status

### Factory Inventory and Governance

List every Data Factory in a subscription to feed governance dashboards, validate that each factory has source control configured, and audit linked services for unsafe or missing connection-string secrets. The Factories_List, Factories_ListByResourceGroup, and per-factory linked services list endpoints together support this audit pattern with a few API calls.

Example prompt: List all Data Factories in subscription /subscriptions/{id}, then for each factory list its linked services and report any whose annotations are missing

### AI Agent ETL Operations

An AI agent supporting a data engineering team can manage Data Factory through Jentic. The agent searches by intent ('create data factory linked service'), Jentic returns the LinkedServices_CreateOrUpdate operation with its schema, and the agent executes the call with managed Azure credentials. The same flow handles factory creation, integration runtime setup, and debug session lifecycle without manual portal steps.

Example prompt: Search Jentic for 'create an Azure Data Factory linked service', load the LinkedServices_CreateOrUpdate schema, and execute it with the user-supplied connectionString and runtime reference

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| GET | /subscriptions/{subscriptionId}/providers/Microsoft.DataFactory/factories | List all Data Factories in a subscription |
| DELETE | /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName} | Delete a Data Factory |
| POST | /subscriptions/{subscriptionId}/providers/Microsoft.DataFactory/locations/{locationId}/configureFactoryRepo | Configure factory repo settings at a location |
| POST | /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/createDataFlowDebugSession | Create a data flow debug session |
| POST | /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/addDataFlowToDebugSession | Add a data flow to a debug session |
| GET | /providers/Microsoft.DataFactory/operations | List Microsoft.DataFactory operations |

## Key resources

- **Factories** — Provision and manage Data Factory instances and their repo configuration
- **LinkedServices** — Manage connection definitions to source and sink stores
- **Datasets** — Define dataset shapes consumed by pipelines and data flows
- **Pipelines** — Define and run pipelines that compose activities and data flows
- **Triggers** — Define schedule, tumbling-window, and event-based triggers
- **IntegrationRuntimes** — Provision self-hosted and Azure-hosted integration runtimes for ETL
- **DataFlowDebugSession** — Create and operate data flow debug sessions for in-development pipelines
- **ExposureControl** — Query feature exposure-control values at the factory level

## Why Jentic

- **Setup:** Wiring Azure Data Factory by hand means registering an Azure AD app, handling MSAL bearer tokens against management.azure.com with the user_impersonation scope, and marshalling the varied schemas across factories, linked services, pipelines, triggers, and integration runtimes yourself. Through Jentic you install once, import Data Factory Management from the API Directory, store the Azure service principal credential once, and your agent calls it.
- **Permission scoping:** Data Factory puts the factory name in the URL path (/subscriptions/{id}/resourceGroups/{rg}/providers/Microsoft.DataFactory/factories/{factoryName}/...), so a rule can pin your agent to one factory and its linked services, datasets, and pipelines. You choose the operations it may call, so destructive ones like Factories_Delete or LinkedServices_Delete are not included unless you add them.
- **Credential handling:** Your Azure service principal credential is stored once, encrypted, by your own Jentic One instance and injected as a scoped ARM bearer token at execution time; linked-service connection strings stay server-side and the credential never enters the agent's prompt, logs, or context.
- **Discovery method:** Agents search Jentic by intent such as 'create a Data Factory linked service' or 'list Data Factory triggers', and Jentic returns the matching operation with its input schema so the agent supplies the connection details without loading all 76 endpoints.

## Related APIs

- **Databricks Management** — Run heavy Spark and Delta Lake workloads from Data Factory pipelines.
- **Data Lake Store Account Management** — Provision Data Lake storage that Data Factory pipelines read from and write to.
- **Stream Analytics Management** — Continuous streaming analytics on Azure instead of batch ETL pipelines.

## FAQ

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

Microsoft Azure does not publish an OpenAPI specification. Jentic generates and maintains this spec so that AI agents and developers can call DataFactoryManagementClient 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 Data Factory management API use?

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

### Can I create linked services and pipelines through this API?

Yes. LinkedServices_CreateOrUpdate, Datasets_CreateOrUpdate, Pipelines_CreateOrUpdate, and Triggers_CreateOrUpdate are all in the spec - together they cover every artefact required to define an ETL workflow. Triggers must be started separately via Triggers_Start to begin execution.

### What are the rate limits for the Data Factory management API?

Azure Resource Manager applies subscription-level read and write throttling (around 1,200 requests per hour). Data Factory additionally throttles concurrent pipeline runs based on the integration runtime's compute size; see IntegrationRuntime_GetStatus for current capacity.

### How do I create a self-hosted integration runtime through Jentic?

Run pip install jentic and search for 'create data factory self-hosted integration runtime'. Jentic returns the IntegrationRuntimes_CreateOrUpdate operation; load its schema and execute it with kind 'SelfHosted'. Then call IntegrationRuntimes_ListAuthKeys to retrieve the key needed by the on-premises installer.

### Does this API trigger pipeline runs?

Pipeline run creation is in the spec at the Pipelines/createRun and PipelineRuns endpoints. Use those to trigger a run or query historical runs. Trigger-based runs require Triggers_Start to enable the trigger first.

### Can I limit what my agent is allowed to do with the Data Factory Management API?

Yes. Because your Jentic One instance is self-hosted, your own rules decide which operations and credentials the agent may use. Since Data Factory carries the factory name in the URL path, you can pin the agent to a single factory and its linked services, datasets, and pipelines, and you choose which operations it may call. Destructive calls such as Factories_Delete or LinkedServices_Delete stay out of reach unless you explicitly add them.