diff --git a/src/client/api.ts b/src/client/api.ts
index 366515da3e83..78663feab712 100644
--- a/src/client/api.ts
+++ b/src/client/api.ts
@@ -4,9 +4,11 @@
 'use strict';
 
 import { noop } from 'lodash';
+import { Uri, Event } from 'vscode';
 import { IExtensionApi } from './apiTypes';
 import { isTestExecution } from './common/constants';
 import { IConfigurationService, Resource } from './common/types';
+import { IEnvironmentVariablesProvider } from './common/variables/types';
 import { getDebugpyLauncherArgs, getDebugpyPackagePath } from './debugger/extension/adapter/remoteLaunchers';
 import { IInterpreterService } from './interpreter/contracts';
 import { IServiceContainer, IServiceManager } from './ioc/types';
@@ -22,7 +24,17 @@ export function buildApi(
     const interpreterService = serviceContainer.get<IInterpreterService>(IInterpreterService);
     serviceManager.addSingleton<JupyterExtensionIntegration>(JupyterExtensionIntegration, JupyterExtensionIntegration);
     const jupyterIntegration = serviceContainer.get<JupyterExtensionIntegration>(JupyterExtensionIntegration);
-    const api: IExtensionApi = {
+    const envService = serviceContainer.get<IEnvironmentVariablesProvider>(IEnvironmentVariablesProvider);
+    const api: IExtensionApi & {
+        /**
+         * @deprecated Temporarily exposed for Pylance until we expose this API generally. Will be removed in an
+         * iteration or two.
+         */
+        pylance: {
+            getPythonPathVar: (resource?: Uri) => Promise<string | undefined>;
+            readonly onDidEnvironmentVariablesChange: Event<Uri | undefined>;
+        };
+    } = {
         // 'ready' will propagate the exception, but we must log it here first.
         ready: ready.catch((ex) => {
             traceError('Failure during activation.', ex);
@@ -65,6 +77,13 @@ export function buildApi(
                 ? jupyterIntegration.showDataViewer.bind(jupyterIntegration)
                 : (noop as any),
         },
+        pylance: {
+            getPythonPathVar: async (resource?: Uri) => {
+                const envs = await envService.getEnvironmentVariables(resource);
+                return envs.PYTHONPATH;
+            },
+            onDidEnvironmentVariablesChange: envService.onDidEnvironmentVariablesChange,
+        },
     };
 
     // In test environment return the DI Container.
diff --git a/src/test/api.functional.test.ts b/src/test/api.functional.test.ts
index 08b0281b4d54..490b5d86b8b3 100644
--- a/src/test/api.functional.test.ts
+++ b/src/test/api.functional.test.ts
@@ -12,6 +12,7 @@ import { buildApi } from '../client/api';
 import { ConfigurationService } from '../client/common/configuration/service';
 import { EXTENSION_ROOT_DIR } from '../client/common/constants';
 import { IConfigurationService } from '../client/common/types';
+import { IEnvironmentVariablesProvider } from '../client/common/variables/types';
 import { IInterpreterService } from '../client/interpreter/contracts';
 import { InterpreterService } from '../client/interpreter/interpreterService';
 import { ServiceContainer } from '../client/ioc/container';
@@ -27,16 +28,21 @@ suite('Extension API', () => {
     let serviceManager: IServiceManager;
     let configurationService: IConfigurationService;
     let interpreterService: IInterpreterService;
+    let environmentVariablesProvider: IEnvironmentVariablesProvider;
 
     setup(() => {
         serviceContainer = mock(ServiceContainer);
         serviceManager = mock(ServiceManager);
         configurationService = mock(ConfigurationService);
         interpreterService = mock(InterpreterService);
+        environmentVariablesProvider = mock<IEnvironmentVariablesProvider>();
 
         when(serviceContainer.get<IConfigurationService>(IConfigurationService)).thenReturn(
             instance(configurationService),
         );
+        when(serviceContainer.get<IEnvironmentVariablesProvider>(IEnvironmentVariablesProvider)).thenReturn(
+            instance(environmentVariablesProvider),
+        );
         when(serviceContainer.get<IInterpreterService>(IInterpreterService)).thenReturn(instance(interpreterService));
     });