Fix STATUS_TRANSACTION_NOT_REQUESTED (0XC0190014) in SQL Server

30-Second Fix: Check Your Connection String

I've seen this exact error pop up when an application or script that uses SQL Server sets off a transaction but the connection string is missing the right driver or has a broken AutoCommit setting. Fastest thing you can do: open your application's config file (like web.config or app.config) and look for the connection string. If it uses Provider=SQLOLEDB or Driver={SQL Server}, switch to Driver={ODBC Driver 17 for SQL Server} or Driver={ODBC Driver 18 for SQL Server} (if you're on Server 2019+). Also add AutoCommit=0 if you see it missing. I had a client last month whose entire ERP system crashed because a dev accidentally used the old SQLOLEDB provider—swapping it fixed it in under a minute.

If that's not the issue, move to the next step.

5-Minute Fix: Verify Transaction Scope in Your Code or Stored Procedure

This error literally means your SQL code started a transaction without a matching BEGIN TRANSACTION that was expected, or you're trying to commit/rollback a transaction that doesn't exist in the current scope. Here's the real-world trigger: someone writes a stored procedure that calls COMMIT TRANSACTION but the procedure was executed outside an explicit transaction, or a nested transaction gets mismatched.

Open SQL Server Management Studio (SSMS) and run this to find any open transactions:

DBCC OPENTRAN;

If it returns results, there's a hanging transaction. Kill it with KILL {spid}. But don't stop there—find the culprit. Run:

SELECT @@TRANCOUNT;

If it returns a number higher than 0, you have an open transaction in your session. Roll it back with ROLLBACK TRANSACTION. Then review the code. Typical mistake: a BEGIN TRY...END TRY block catches an error but doesn't properly handle COMMIT or ROLLBACK. I've seen this in apps using Entity Framework or ADO.NET where the transaction object is disposed without being committed or rolled back.

If you're using ADO.NET, make sure you wrap your code like:

using (SqlConnection conn = new SqlConnection(connectionString)) {
    conn.Open();
    using (SqlTransaction tran = conn.BeginTransaction()) {
        try {
            // your SQL commands
            tran.Commit();
        } catch {
            tran.Rollback();
            throw;
        }
    }
}

This ensures the transaction is always properly ended.

Advanced Fix (15+ minutes): Investigate Linked Servers or DTC Issues

If the error happens when you're using linked servers or distributed transactions (like across two SQL Server instances or between SQL Server and an Oracle database), the problem is probably with the Microsoft Distributed Transaction Coordinator (MSDTC). This one's a beast. The error STATUS_TRANSACTION_NOT_REQUESTED can show up when a remote server doesn't see the transaction that the local server thinks it started.

First, check MSDTC is running on both servers. Open Services.msc, find Distributed Transaction Coordinator, and ensure it's set to Automatic and started. Then configure firewall rules to allow MSDTC traffic—ports 135, 1024-65535 for RPC dynamic ports. You'll also need to enable network DTC access. Run dcomcnfg, go to Component Services > Computers > My Computer > Distributed Transaction Coordinator, right-click Local DTC, select Properties, and on the Security tab, check Network DTC Access, Allow Inbound, Allow Outbound, and No Authentication Required (for testing only—lock it down later).

Another advanced fix: check your stored procedure for nested transactions. SQL Server doesn't support truly nested transactions—each BEGIN TRANSACTION increments @@TRANCOUNT, and only the outermost COMMIT actually writes. If you have a stored procedure that starts a transaction and then calls another stored procedure that also starts a transaction, but then commits inside the inner procedure, it can leave the outer transaction dangling. The fix is to use SAVE TRANSACTION and ROLLBACK TRAN with a save point name, or redesign to avoid nesting. I've had to rewrite a whole batch of stored procedures for a logistics company because of this exact pattern—took about two hours, but the error stopped cold.

Finally, if you're using ODBC in a legacy app (like a FoxPro or Access front-end), sometimes the ODBC driver itself keeps a transaction open. Restart the application and the SQL Server service to clear it. In SSMS, run DBCC FREEPROCCACHE after restarting—it flushes the plan cache and forces a clean state.

Bottom line: start with the connection string and transaction scope—90% of the time that's the fix. Only go down the DTC rabbit hole if you're working across servers and the simpler steps didn't work.