diff --git a/backend/shared/model/south-connector.model.ts b/backend/shared/model/south-connector.model.ts
index 4a9ca51897..ecace81a6c 100644
--- a/backend/shared/model/south-connector.model.ts
+++ b/backend/shared/model/south-connector.model.ts
@@ -19,6 +19,7 @@ export const OIBUS_SOUTH_TYPES = [
   'opcua',
   'oracle',
   'osisoft-pi',
+  'osisoft-pi-webapi',
   'postgresql',
   'sftp',
   'sqlite'
@@ -118,3 +119,17 @@ export interface SouthCache {
   itemId: string;
   maxInstant: Instant;
 }
+
+export interface AvailablePoint {
+  id: string;
+  name: string;
+  description?: string;
+  // PI Web API specific properties
+  webId?: string;
+  pointClass?: string;
+  pointType?: string;
+  path?: string;
+  engineeringUnits?: string;
+  // Generic index signature for connector-specific properties
+  [key: string]: string | number | boolean | undefined;
+}
diff --git a/backend/shared/model/south-settings.model.ts b/backend/shared/model/south-settings.model.ts
index e5dad30a45..f9d56c607d 100644
--- a/backend/shared/model/south-settings.model.ts
+++ b/backend/shared/model/south-settings.model.ts
@@ -572,6 +572,7 @@ export type SouthSettings =
   | SouthOPCUASettings
   | SouthOracleSettings
   | SouthPISettings
+  | SouthPIWebAPISettings
   | SouthPostgreSQLSettings
   | SouthSFTPSettings
   | SouthSQLiteSettings;
@@ -830,6 +831,28 @@ export interface SouthPIItemSettings {
   piQuery?: string;
 }
 
+export interface SouthPIWebAPISettingsThrottling {
+  maxReadInterval: number;
+  readDelay: number;
+  overlap: number;
+  maxInstantPerItem: boolean;
+}
+
+export interface SouthPIWebAPISettings {
+  throttling: SouthPIWebAPISettingsThrottling;
+  url: string;
+  dataServerWebId: string;
+  username: string;
+  password: string | null;
+  acceptUnauthorized: boolean;
+  timeout: number;
+  retryInterval: number;
+}
+
+export interface SouthPIWebAPIItemSettings {
+  pointWebId: string;
+}
+
 export interface SouthPostgreSQLItemSettings {
   query: string;
   dateTimeFields: Array<SouthPostgreSQLItemSettingsDateTimeFields> | null;
@@ -864,6 +887,7 @@ export type SouthItemSettings =
   | SouthOPCUAItemSettings
   | SouthOracleItemSettings
   | SouthPIItemSettings
+  | SouthPIWebAPIItemSettings
   | SouthPostgreSQLItemSettings
   | SouthSFTPItemSettings
   | SouthSQLiteItemSettings;
diff --git a/backend/src/service/south.service.ts b/backend/src/service/south.service.ts
index 3d2305672b..2322e2bf3f 100644
--- a/backend/src/service/south.service.ts
+++ b/backend/src/service/south.service.ts
@@ -3,6 +3,7 @@ import pino from 'pino';
 
 // South imports
 import {
+  AvailablePoint,
   SouthConnectorCommandDTO,
   SouthConnectorDTO,
   SouthConnectorItemCommandDTO,
@@ -29,6 +30,7 @@ import sqliteManifest from '../south/south-sqlite/manifest';
 import opcManifest from '../south/south-opc/manifest';
 import oledbManifest from '../south/south-oledb/manifest';
 import piManifest from '../south/south-pi/manifest';
+import piWebAPIManifest from '../south/south-pi-webapi/manifest';
 import sftpManifest from '../south/south-sftp/manifest';
 import ConnectionService from './connection.service';
 import { OIBusContent } from '../../shared/model/engine.model';
@@ -75,6 +77,8 @@ import {
   SouthOracleSettings,
   SouthPIItemSettings,
   SouthPISettings,
+  SouthPIWebAPIItemSettings,
+  SouthPIWebAPISettings,
   SouthPostgreSQLItemSettings,
   SouthPostgreSQLSettings,
   SouthSettings,
@@ -96,6 +100,7 @@ import SouthOPC from '../south/south-opc/south-opc';
 import SouthOPCUA from '../south/south-opcua/south-opcua';
 import SouthOracle from '../south/south-oracle/south-oracle';
 import SouthPI from '../south/south-pi/south-pi';
+import SouthPIWebAPI from '../south/south-pi-webapi/south-pi-webapi';
 import SouthPostgreSQL from '../south/south-postgresql/south-postgresql';
 import SouthSFTP from '../south/south-sftp/south-sftp';
 import SouthSQLite from '../south/south-sqlite/south-sqlite';
@@ -121,6 +126,7 @@ export const southManifestList: Array<SouthConnectorManifest> = [
   modbusManifest,
   oianalyticsManifest,
   piManifest,
+  piWebAPIManifest,
   sftpManifest
 ];
 
@@ -295,6 +301,17 @@ export default class SouthService {
           logger,
           southBaseFolders
         );
+      case 'osisoft-pi-webapi':
+        return new SouthPIWebAPI(
+          settings as SouthConnectorEntity<SouthPIWebAPISettings, SouthPIWebAPIItemSettings>,
+          addContent,
+          this.encryptionService,
+          this.southConnectorRepository,
+          this.southCacheRepository,
+          this.scanModeRepository,
+          logger,
+          southBaseFolders
+        );
       case 'postgresql':
         return new SouthPostgreSQL(
           settings as SouthConnectorEntity<SouthPostgreSQLSettings, SouthPostgreSQLItemSettings>,
@@ -424,6 +441,53 @@ export default class SouthService {
     return await south.testItem(testItemToRun, testingSettings, callback);
   }
 
+  async browseItems<S extends SouthSettings, I extends SouthItemSettings>(
+    id: string,
+    command: SouthConnectorCommandDTO<S, I>,
+    logger: pino.Logger,
+    nameFilter?: string,
+    maxPoints?: number
+  ): Promise<Array<AvailablePoint>> {
+    let southConnector: SouthConnectorEntity<S, I> | null = null;
+    if (id !== 'create') {
+      southConnector = this.southConnectorRepository.findSouthById(id);
+      if (!southConnector) {
+        throw new Error(`South connector ${id} not found`);
+      }
+    }
+    const manifest = this.getInstalledSouthManifests().find(southManifest => southManifest.id === command.type);
+    if (!manifest) {
+      throw new Error(`South manifest ${command.type} not found`);
+    }
+
+    const testConnectorToRun: SouthConnectorEntity<SouthSettings, SouthItemSettings> = {
+      id: southConnector?.id || 'test',
+      ...command,
+      settings: await this.encryptionService.encryptConnectorSecrets<S>(
+        command.settings,
+        southConnector?.settings || null,
+        manifest.settings
+      ),
+      name: southConnector ? southConnector.name : `${command!.type}:browse-items`,
+      items: []
+    };
+
+    /* istanbul ignore next */
+    const mockedAddContent = async (_southId: string, _content: OIBusContent): Promise<void> => Promise.resolve();
+    const south = this.runSouth(testConnectorToRun, mockedAddContent, logger, {
+      cache: 'baseCacheFolder',
+      archive: 'baseArchiveFolder',
+      error: 'baseErrorFolder'
+    });
+
+    // Check if the connector has getAvailablePoints method
+    if ('getAvailablePoints' in south && typeof south.getAvailablePoints === 'function') {
+      return await south.getAvailablePoints(nameFilter, maxPoints);
+    } else {
+      throw new Error(`Connector type ${command.type} does not support browsing available items`);
+    }
+  }
+
   findById<S extends SouthSettings, I extends SouthItemSettings>(southId: string): SouthConnectorEntity<S, I> | null {
     return this.southConnectorRepository.findSouthById(southId);
   }
diff --git a/backend/src/south/south-pi-webapi/manifest.ts b/backend/src/south/south-pi-webapi/manifest.ts
new file mode 100644
index 0000000000..cfeb8f257b
--- /dev/null
+++ b/backend/src/south/south-pi-webapi/manifest.ts
@@ -0,0 +1,136 @@
+import { SouthConnectorManifest } from '../../../shared/model/south-connector.model';
+
+const manifest: SouthConnectorManifest = {
+  id: 'osisoft-pi-webapi',
+  category: 'api',
+  modes: {
+    subscription: false,
+    lastPoint: false,
+    lastFile: false,
+    history: true
+  },
+  settings: [
+    {
+      key: 'throttling',
+      type: 'OibFormGroup',
+      translationKey: 'south.osisoft-pi-webapi.throttling.title',
+      class: 'col',
+      newRow: true,
+      displayInViewMode: false,
+      validators: [{ key: 'required' }],
+      content: [
+        {
+          key: 'maxReadInterval',
+          type: 'OibNumber',
+          translationKey: 'south.osisoft-pi-webapi.throttling.max-read-interval',
+          validators: [{ key: 'required' }, { key: 'min', params: { min: 0 } }],
+          defaultValue: 3600,
+          unitLabel: 's',
+          displayInViewMode: true
+        },
+        {
+          key: 'readDelay',
+          type: 'OibNumber',
+          translationKey: 'south.osisoft-pi-webapi.throttling.read-delay',
+          validators: [{ key: 'required' }, { key: 'min', params: { min: 0 } }],
+          defaultValue: 200,
+          unitLabel: 'ms',
+          displayInViewMode: true
+        },
+        {
+          key: 'overlap',
+          type: 'OibNumber',
+          translationKey: 'south.osisoft-pi-webapi.throttling.overlap',
+          validators: [{ key: 'required' }, { key: 'min', params: { min: 0 } }],
+          defaultValue: 0,
+          unitLabel: 'ms',
+          displayInViewMode: true
+        },
+        {
+          key: 'maxInstantPerItem',
+          type: 'OibCheckbox',
+          translationKey: 'south.osisoft-pi-webapi.throttling.max-instant-per-item',
+          defaultValue: false,
+          validators: [{ key: 'required' }],
+          displayInViewMode: true
+        }
+      ]
+    },
+    {
+      key: 'url',
+      type: 'OibText',
+      translationKey: 'south.osisoft-pi-webapi.url',
+      defaultValue: 'https://pi.dev.metroscope.io/piwebapi/',
+      validators: [{ key: 'required' }],
+      newRow: true,
+      displayInViewMode: true
+    },
+    {
+      key: 'dataServerWebId',
+      type: 'OibText',
+      translationKey: 'south.osisoft-pi-webapi.data-server-web-id',
+      defaultValue: 'F1DSC4n4q_2uRUWxuLuRsKCl8QVk0tUEktU0VSVkVSLVRF',
+      validators: [{ key: 'required' }],
+      newRow: true,
+      displayInViewMode: true
+    },
+    {
+      key: 'username',
+      type: 'OibText',
+      translationKey: 'south.osisoft-pi-webapi.username',
+      validators: [{ key: 'required' }],
+      newRow: true,
+      displayInViewMode: true
+    },
+    {
+      key: 'password',
+      type: 'OibSecret',
+      translationKey: 'south.osisoft-pi-webapi.password',
+      class: 'col-4',
+      displayInViewMode: false
+    },
+    {
+      key: 'acceptUnauthorized',
+      type: 'OibCheckbox',
+      translationKey: 'south.osisoft-pi-webapi.accept-unauthorized',
+      defaultValue: false,
+      validators: [{ key: 'required' }],
+      class: 'col-4',
+      displayInViewMode: true
+    },
+    {
+      key: 'timeout',
+      type: 'OibNumber',
+      translationKey: 'south.osisoft-pi-webapi.timeout',
+      defaultValue: 30,
+      unitLabel: 's',
+      class: 'col-3',
+      validators: [{ key: 'required' }, { key: 'min', params: { min: 1 } }, { key: 'max', params: { max: 300 } }],
+      displayInViewMode: true
+    },
+    {
+      key: 'retryInterval',
+      type: 'OibNumber',
+      translationKey: 'south.osisoft-pi-webapi.retry-interval',
+      defaultValue: 10000,
+      unitLabel: 'ms',
+      class: 'col-3',
+      validators: [{ key: 'required' }, { key: 'min', params: { min: 100 } }, { key: 'max', params: { max: 30000 } }],
+      displayInViewMode: true
+    }
+  ],
+  items: {
+    scanMode: 'POLL',
+    settings: [
+      {
+        key: 'pointWebId',
+        type: 'OibText',
+        translationKey: 'south.osisoft-pi-webapi.point-web-id',
+        validators: [{ key: 'required' }],
+        displayInViewMode: false,
+        class: 'col-12 d-none' // Hidden field - set programmatically
+      }
+    ]
+  }
+};
+export default manifest;
diff --git a/backend/src/south/south-pi-webapi/south-pi-webapi.spec.ts b/backend/src/south/south-pi-webapi/south-pi-webapi.spec.ts
new file mode 100644
index 0000000000..9f1c130467
--- /dev/null
+++ b/backend/src/south/south-pi-webapi/south-pi-webapi.spec.ts
@@ -0,0 +1,103 @@
+import SouthPIWebAPI from './south-pi-webapi';
+import { SouthPIWebAPISettings, SouthPIWebAPIItemSettings } from '../../../shared/model/south-settings.model';
+import { SouthConnectorEntity } from '../../model/south-connector.model';
+import EncryptionService from '../../service/encryption.service';
+import EncryptionServiceMock from '../../tests/__mocks__/service/encryption-service.mock';
+import SouthConnectorRepository from '../../repository/config/south-connector.repository';
+import SouthCacheRepository from '../../repository/cache/south-cache.repository';
+import ScanModeRepository from '../../repository/config/scan-mode.repository';
+import pino from 'pino';
+
+// Mock implementations for testing
+const mockEncryptionService: EncryptionService = new EncryptionServiceMock('', '');
+const mockSouthConnectorRepository = {} as SouthConnectorRepository;
+const mockSouthCacheRepository = {} as SouthCacheRepository;
+const mockScanModeRepository = {} as ScanModeRepository;
+const mockLogger = pino();
+const mockBaseFolders = {
+  cache: '/tmp/cache',
+  archive: '/tmp/archive',
+  error: '/tmp/error'
+};
+
+const mockSettings: SouthPIWebAPISettings = {
+  throttling: {
+    maxReadInterval: 3600,
+    readDelay: 200,
+    overlap: 0,
+    maxInstantPerItem: false
+  },
+  url: 'https://pi.dev.metroscope.io/piwebapi/',
+  dataServerWebId: 'F1DSC4n4q_2uRUWxuLuRsKCl8QVk0tUEktU0VSVkVSLVRF',
+  username: 'testuser',
+  password: 'testpass',
+  acceptUnauthorized: false,
+  timeout: 30,
+  retryInterval: 10000
+};
+
+const mockItemSettings: SouthPIWebAPIItemSettings = {
+  pointWebId: 'F1DPC4n4q_2uRUWxuLuRsKCl8QBAAAAAVk0tUEktU0VSVkVSLVRFXENISUxMRVJfT05fQ0hJTExFUl8xMDE'
+};
+
+const mockConnector: SouthConnectorEntity<SouthPIWebAPISettings, SouthPIWebAPIItemSettings> = {
+  id: 'test-pi-webapi',
+  name: 'Test PI Web API',
+  type: 'osisoft-pi-webapi',
+  description: 'Test PI Web API connector',
+  enabled: true,
+  settings: mockSettings,
+  items: [
+    {
+      id: 'item1',
+      name: 'chiller_on_chiller_101',
+      enabled: true,
+      settings: mockItemSettings,
+      scanModeId: 'scanMode1'
+    }
+  ]
+};
+
+describe('SouthPIWebAPI', () => {
+  let connector: SouthPIWebAPI;
+
+  beforeEach(() => {
+    connector = new SouthPIWebAPI(
+      mockConnector,
+      jest.fn(),
+      mockEncryptionService,
+      mockSouthConnectorRepository,
+      mockSouthCacheRepository,
+      mockScanModeRepository,
+      mockLogger,
+      mockBaseFolders
+    );
+  });
+
+  it('should create an instance', () => {
+    expect(connector).toBeDefined();
+    expect(connector).toBeInstanceOf(SouthPIWebAPI);
+  });
+
+  it('should have correct throttling settings', () => {
+    const throttling = connector.getThrottlingSettings(mockSettings);
+    expect(throttling.maxReadInterval).toBe(3600);
+    expect(throttling.readDelay).toBe(200);
+  });
+
+  it('should handle max instant per item setting', () => {
+    expect(connector.getMaxInstantPerItem(mockSettings)).toBe(false);
+  });
+
+  it('should handle overlap setting', () => {
+    expect(connector.getOverlap(mockSettings)).toBe(0);
+  });
+
+  it('should ensure URL ends with slash', () => {
+    const result = connector.ensureUrlEndsWithSlash('https://example.com');
+    expect(result).toBe('https://example.com/');
+
+    const resultWithSlash = connector.ensureUrlEndsWithSlash('https://example.com/');
+    expect(resultWithSlash).toBe('https://example.com/');
+  });
+});
diff --git a/backend/src/south/south-pi-webapi/south-pi-webapi.ts b/backend/src/south/south-pi-webapi/south-pi-webapi.ts
new file mode 100644
index 0000000000..e1da46bd44
--- /dev/null
+++ b/backend/src/south/south-pi-webapi/south-pi-webapi.ts
@@ -0,0 +1,373 @@
+import SouthConnector from '../south-connector';
+import EncryptionService from '../../service/encryption.service';
+import pino from 'pino';
+import { Instant } from '../../../shared/model/types';
+import { DateTime } from 'luxon';
+import { QueriesHistory } from '../south-interface';
+import { SouthPIWebAPIItemSettings, SouthPIWebAPISettings } from '../../../shared/model/south-settings.model';
+import { OIBusContent, OIBusTimeValue } from '../../../shared/model/engine.model';
+import { SouthConnectorEntity, SouthConnectorItemEntity, SouthThrottlingSettings } from '../../model/south-connector.model';
+import SouthConnectorRepository from '../../repository/config/south-connector.repository';
+import SouthCacheRepository from '../../repository/cache/south-cache.repository';
+import ScanModeRepository from '../../repository/config/scan-mode.repository';
+import { BaseFolders } from '../../model/types';
+import { SouthConnectorItemTestingSettings, AvailablePoint } from '../../../shared/model/south-connector.model';
+import { HTTPRequest, ReqAuthOptions, ReqOptions } from '../../service/http-request.utils';
+
+interface PIWebAPIPoint {
+  WebId: string;
+  Id: number;
+  Name: string;
+  Path: string;
+  Descriptor: string;
+  PointClass: string;
+  PointType: string;
+  DigitalSetName: string;
+  EngineeringUnits: string;
+  Span: number;
+  Zero: number;
+  Step: boolean;
+  Future: boolean;
+  DisplayDigits: number;
+  Links: {
+    Self: string;
+    DataServer: string;
+    Attributes: string;
+    InterpolatedData: string;
+    RecordedData: string;
+    PlotData: string;
+    SummaryData: string;
+    Value: string;
+    EndValue: string;
+  };
+}
+
+interface PIWebAPIPointsResponse {
+  Links: Record<string, unknown>;
+  Items: Array<PIWebAPIPoint>;
+}
+
+interface PIWebAPIRecordedValue {
+  Timestamp: string;
+  UnitsAbbreviation: string;
+  Good: boolean;
+  Questionable: boolean;
+  Substituted: boolean;
+  Annotated: boolean;
+  Value: number | string | boolean;
+  Annotations?: Array<{
+    Id: string;
+    Name: string;
+    Description: string;
+    Value: string;
+    Creator: string;
+    CreationDate: string;
+    Modifier: string;
+    ModifyDate: string;
+    Errors: unknown;
+  }>;
+}
+
+interface PIWebAPIRecordedResponse {
+  Items: Array<PIWebAPIRecordedValue>;
+  Links: Record<string, unknown>;
+}
+
+/**
+ * Class SouthPIWebAPI - Connect to OSIsoft PI Web API to retrieve historical data
+ */
+export default class SouthPIWebAPI extends SouthConnector<SouthPIWebAPISettings, SouthPIWebAPIItemSettings> implements QueriesHistory {
+  private connected = false;
+  private reconnectTimeout: NodeJS.Timeout | null = null;
+  private disconnecting = false;
+
+  constructor(
+    connector: SouthConnectorEntity<SouthPIWebAPISettings, SouthPIWebAPIItemSettings>,
+    engineAddContentCallback: (southId: string, data: OIBusContent) => Promise<void>,
+    encryptionService: EncryptionService,
+    southConnectorRepository: SouthConnectorRepository,
+    southCacheRepository: SouthCacheRepository,
+    scanModeRepository: ScanModeRepository,
+    logger: pino.Logger,
+    baseFolders: BaseFolders
+  ) {
+    super(
+      connector,
+      engineAddContentCallback,
+      encryptionService,
+      southConnectorRepository,
+      southCacheRepository,
+      scanModeRepository,
+      logger,
+      baseFolders
+    );
+  }
+
+  async connect(): Promise<void> {
+    if (this.reconnectTimeout) {
+      clearTimeout(this.reconnectTimeout);
+      this.reconnectTimeout = null;
+    }
+
+    try {
+      // Test connection by trying to get data server info
+      await this.testConnection();
+      this.connected = true;
+      await super.connect();
+    } catch (error) {
+      this.logger.error(`Error while connecting to PI Web API. Reconnecting in ${this.connector.settings.retryInterval} ms. ${error}`);
+      if (!this.disconnecting && this.connector.enabled && !this.reconnectTimeout) {
+        await this.disconnect();
+        this.reconnectTimeout = setTimeout(this.connect.bind(this), this.connector.settings.retryInterval);
+      }
+    }
+  }
+
+  async testConnection(): Promise<void> {
+    try {
+      // Validate required settings
+      if (!this.connector.settings.url) {
+        throw new Error('PI Web API URL is required');
+      }
+      if (!this.connector.settings.dataServerWebId) {
+        throw new Error('Data Server Web ID is required');
+      }
+      if (!this.connector.settings.username) {
+        throw new Error('Username is required');
+      }
+      if (!this.connector.settings.password) {
+        throw new Error('Password is required');
+      }
+
+      const fetchOptions = this.createHttpOptions('GET');
+      const requestUrl = new URL(
+        `dataservers/${this.connector.settings.dataServerWebId}`,
+        this.ensureUrlEndsWithSlash(this.connector.settings.url)
+      );
+
+      const response = await HTTPRequest(requestUrl, fetchOptions);
+
+      if (!response.ok) {
+        throw new Error(`PI Web API connection test failed with status ${response.statusCode}`);
+      }
+
+      this.logger.info('PI Web API connection test successful');
+    } catch (error) {
+      throw new Error(`PI Web API connection test failed: ${error}`);
+    }
+  }
+
+  override async testItem(
+    item: SouthConnectorItemEntity<SouthPIWebAPIItemSettings>,
+    testingSettings: SouthConnectorItemTestingSettings,
+    callback: (data: OIBusContent) => void
+  ): Promise<void> {
+    const content: OIBusContent = { type: 'time-values', content: [] };
+
+    const startTime = testingSettings.history!.startTime;
+    const endTime = testingSettings.history!.endTime;
+
+    try {
+      const values = await this.queryRecordedData(item.settings.pointWebId, startTime, endTime);
+      content.content = values;
+      callback(content);
+    } catch (error) {
+      throw new Error(`Error testing PI Web API item: ${error}`);
+    }
+  }
+
+  /**
+   * Get entries from PI Web API between startTime and endTime
+   */
+  async historyQuery(
+    items: Array<SouthConnectorItemEntity<SouthPIWebAPIItemSettings>>,
+    startTime: Instant,
+    endTime: Instant
+  ): Promise<Instant | null> {
+    let updatedStartTime: Instant | null = null;
+    this.logger.debug(`Requesting ${items.length} items between ${startTime} and ${endTime}`);
+    const startRequest = DateTime.now().toMillis();
+
+    const allValues: Array<OIBusTimeValue> = [];
+    let maxTimestamp = new Date(startTime).getTime();
+
+    try {
+      // Process items in parallel but with some throttling to avoid overwhelming the API
+      const batchSize = 10;
+      for (let i = 0; i < items.length; i += batchSize) {
+        const batch = items.slice(i, i + batchSize);
+        const batchPromises = batch.map(async item => {
+          try {
+            const values = await this.queryRecordedData(item.settings.pointWebId, startTime, endTime);
+            return { item, values };
+          } catch (error) {
+            this.logger.error(`Error querying item ${item.name}: ${error}`);
+            return { item, values: [] };
+          }
+        });
+
+        const batchResults = await Promise.all(batchPromises);
+
+        for (const { item, values } of batchResults) {
+          // Add point ID to each value
+          const valuesWithPointId = values.map(value => ({
+            ...value,
+            pointId: item.name
+          }));
+
+          allValues.push(...valuesWithPointId);
+
+          // Track the maximum timestamp
+          if (values.length > 0) {
+            const itemMaxTimestamp = Math.max(...values.map(v => new Date(v.timestamp).getTime()));
+            maxTimestamp = Math.max(maxTimestamp, itemMaxTimestamp);
+          }
+        }
+
+        // Add delay between batches to respect API limits
+        if (i + batchSize < items.length) {
+          await new Promise(resolve => setTimeout(resolve, this.connector.settings.throttling.readDelay));
+        }
+      }
+
+      const requestDuration = DateTime.now().toMillis() - startRequest;
+
+      if (allValues.length > 0) {
+        this.logger.debug(`Found ${allValues.length} results for ${items.length} items in ${requestDuration} ms`);
+        await this.addContent({ type: 'time-values', content: allValues });
+
+        if (maxTimestamp > new Date(startTime).getTime()) {
+          updatedStartTime = new Date(maxTimestamp).toISOString();
+        }
+      } else {
+        this.logger.debug(`No result found. Request done in ${requestDuration} ms`);
+      }
+    } catch (error) {
+      throw new Error(`Error querying PI Web API: ${error}`);
+    }
+
+    return updatedStartTime;
+  }
+
+  private async queryRecordedData(pointWebId: string, startTime: Instant, endTime: Instant): Promise<Array<OIBusTimeValue>> {
+    const fetchOptions = this.createHttpOptions('GET');
+
+    // Build URL with query parameters
+    const url = new URL(`streams/${pointWebId}/recorded`, this.ensureUrlEndsWithSlash(this.connector.settings.url));
+    url.searchParams.set('startTime', startTime);
+    url.searchParams.set('endTime', endTime);
+    url.searchParams.set('maxCount', '10000'); // Reasonable limit
+
+    const response = await HTTPRequest(url, fetchOptions);
+
+    if (!response.ok) {
+      const errorText = await response.body.text();
+      throw new Error(`PI Web API query failed with status ${response.statusCode}: ${errorText}`);
+    }
+
+    const data = (await response.body.json()) as PIWebAPIRecordedResponse;
+
+    return data.Items.map(item => {
+      const value = typeof item.Value === 'boolean' ? (item.Value ? 1 : 0) : item.Value;
+      return {
+        pointId: pointWebId,
+        timestamp: item.Timestamp,
+        value: value as string | number,
+        quality: item.Good ? 'GOOD' : item.Questionable ? 'UNCERTAIN' : 'BAD',
+        data: { value: value as string | number }
+      };
+    });
+  }
+
+  private createHttpOptions(method: string): ReqOptions {
+    const auth: ReqAuthOptions = {
+      type: 'basic',
+      username: this.connector.settings.username,
+      password: this.connector.settings.password || ''
+    };
+
+    return {
+      method,
+      headers: {
+        'Content-Type': 'application/json',
+        Accept: 'application/json'
+      },
+      auth,
+      timeout: this.connector.settings.timeout * 1000,
+      acceptUnauthorized: this.connector.settings.acceptUnauthorized
+    };
+  }
+
+  public ensureUrlEndsWithSlash(url: string): string {
+    return url.endsWith('/') ? url : `${url}/`;
+  }
+
+  getThrottlingSettings(settings: SouthPIWebAPISettings): SouthThrottlingSettings {
+    return {
+      maxReadInterval: settings.throttling.maxReadInterval,
+      readDelay: settings.throttling.readDelay
+    };
+  }
+
+  getMaxInstantPerItem(settings: SouthPIWebAPISettings): boolean {
+    return settings.throttling.maxInstantPerItem;
+  }
+
+  getOverlap(settings: SouthPIWebAPISettings): number {
+    return settings.throttling.overlap;
+  }
+
+  async disconnect(): Promise<void> {
+    this.disconnecting = true;
+    if (this.reconnectTimeout) {
+      clearTimeout(this.reconnectTimeout);
+      this.reconnectTimeout = null;
+    }
+    this.connected = false;
+    await super.disconnect();
+    this.disconnecting = false;
+  }
+
+  /**
+   * Get available points from the PI Web API data server
+   * This can be used by the UI to allow users to select points
+   * @param nameFilter - Optional name filter (supports * wildcard like PI queries)
+   * @param maxPoints - Maximum number of points to return (default 1000)
+   */
+  async getAvailablePoints(nameFilter?: string, maxPoints = 1000): Promise<Array<AvailablePoint>> {
+    const fetchOptions = this.createHttpOptions('GET');
+    const requestUrl = new URL(
+      `dataservers/${this.connector.settings.dataServerWebId}/points`,
+      this.ensureUrlEndsWithSlash(this.connector.settings.url)
+    );
+
+    // Add name filter if provided (PI Web API supports wildcards)
+    if (nameFilter) {
+      requestUrl.searchParams.set('nameFilter', nameFilter);
+    }
+
+    // Set max count to avoid overwhelming responses
+    requestUrl.searchParams.set('maxCount', maxPoints.toString());
+
+    const response = await HTTPRequest(requestUrl, fetchOptions);
+
+    if (!response.ok) {
+      const errorText = await response.body.text();
+      throw new Error(`Failed to get PI Web API points with status ${response.statusCode}: ${errorText}`);
+    }
+
+    const data = (await response.body.json()) as PIWebAPIPointsResponse;
+
+    // Convert PI Web API points to generic AvailablePoint format
+    return data.Items.map(point => ({
+      id: point.WebId,
+      name: point.Name,
+      description: point.Descriptor || point.Path,
+      webId: point.WebId,
+      pointClass: point.PointClass,
+      pointType: point.PointType,
+      path: point.Path,
+      engineeringUnits: point.EngineeringUnits
+    }));
+  }
+}
diff --git a/backend/src/web-server/controllers/south-connector.controller.ts b/backend/src/web-server/controllers/south-connector.controller.ts
index f2dcf56842..be486b878f 100644
--- a/backend/src/web-server/controllers/south-connector.controller.ts
+++ b/backend/src/web-server/controllers/south-connector.controller.ts
@@ -1,5 +1,6 @@
 import { KoaContext } from '../koa';
 import {
+  AvailablePoint,
   SouthConnectorCommandDTO,
   SouthConnectorDTO,
   SouthConnectorItemCommandDTO,
@@ -347,4 +348,28 @@ export default class SouthConnectorController {
     }
     ctx.noContent();
   }
+
+  async browseAvailableItems(
+    ctx: KoaContext<SouthConnectorCommandDTO<SouthSettings, SouthItemSettings>, Array<AvailablePoint>>
+  ): Promise<void> {
+    try {
+      const logger = ctx.app.logger.child(
+        {
+          scopeType: 'south',
+          scopeId: 'browse',
+          scopeName: 'browse'
+        },
+        { level: 'silent' }
+      );
+
+      // Extract nameFilter from query parameters
+      const nameFilter = ctx.query.nameFilter as string | undefined;
+      const maxPoints = ctx.query.maxPoints ? parseInt(ctx.query.maxPoints as string, 10) : undefined;
+
+      const result = await ctx.app.southService.browseItems(ctx.params.id, ctx.request.body!, logger, nameFilter, maxPoints);
+      ctx.ok(result);
+    } catch (error: unknown) {
+      ctx.badRequest((error as Error).message);
+    }
+  }
 }
diff --git a/backend/src/web-server/routes/index.ts b/backend/src/web-server/routes/index.ts
index 6de72ea2f1..59eb9d0a30 100644
--- a/backend/src/web-server/routes/index.ts
+++ b/backend/src/web-server/routes/index.ts
@@ -33,6 +33,7 @@ import { ChangePasswordCommand, UserDTO, UserCommandDTO } from '../../../shared/
 import { ScanModeCommandDTO, ScanModeDTO, ValidatedCronExpression } from '../../../shared/model/scan-mode.model';
 import { CertificateCommandDTO, CertificateDTO } from '../../../shared/model/certificate.model';
 import {
+  AvailablePoint,
   SouthConnectorCommandDTO,
   SouthConnectorDTO,
   SouthConnectorItemCommandDTO,
@@ -194,6 +195,11 @@ router.get('/api/south', (ctx: KoaContext<void, Array<SouthConnectorLightDTO>>)
 router.put('/api/south/:id/test-connection', (ctx: KoaContext<SouthConnectorCommandDTO<SouthSettings, SouthItemSettings>, void>) =>
   southConnectorController.testSouthConnection(ctx)
 );
+router.put(
+  '/api/south/:id/browse-items',
+  (ctx: KoaContext<SouthConnectorCommandDTO<SouthSettings, SouthItemSettings>, Array<AvailablePoint>>) =>
+    southConnectorController.browseAvailableItems(ctx)
+);
 router.get('/api/south/:id', (ctx: KoaContext<void, SouthConnectorDTO<SouthSettings, SouthItemSettings>>) =>
   southConnectorController.findById(ctx)
 );
diff --git a/frontend/src/app/services/south-connector.service.ts b/frontend/src/app/services/south-connector.service.ts
index 336ecdb912..6e6a4f6478 100644
--- a/frontend/src/app/services/south-connector.service.ts
+++ b/frontend/src/app/services/south-connector.service.ts
@@ -2,6 +2,7 @@ import { HttpClient } from '@angular/common/http';
 import { map, Observable } from 'rxjs';
 import { Injectable, inject } from '@angular/core';
 import {
+  AvailablePoint,
   SouthConnectorCommandDTO,
   SouthConnectorDTO,
   SouthConnectorManifest,
@@ -262,6 +263,25 @@ export class SouthConnectorService {
     return this.http.put<void>(`/api/south/${southId}/test-connection`, settings);
   }
 
+  browseAvailableItems(
+    southId: string,
+    settings: SouthConnectorCommandDTO<SouthSettings, SouthItemSettings>,
+    params?: { nameFilter?: string; maxPoints?: number }
+  ): Observable<Array<AvailablePoint>> {
+    let url = `/api/south/${southId}/browse-items`;
+    if (params?.nameFilter || params?.maxPoints) {
+      const queryParams = new URLSearchParams();
+      if (params.nameFilter) {
+        queryParams.set('nameFilter', params.nameFilter);
+      }
+      if (params.maxPoints) {
+        queryParams.set('maxPoints', params.maxPoints.toString());
+      }
+      url += `?${queryParams.toString()}`;
+    }
+    return this.http.put<Array<AvailablePoint>>(url, settings);
+  }
+
   startSouth(southId: string): Observable<void> {
     return this.http.put<void>(`/api/south/${southId}/start`, null);
   }
diff --git a/frontend/src/app/shared/test-connection-result-modal/test-connection-result-modal.component.html b/frontend/src/app/shared/test-connection-result-modal/test-connection-result-modal.component.html
index c2a33d36ce..66f3b3ad1b 100644
--- a/frontend/src/app/shared/test-connection-result-modal/test-connection-result-modal.component.html
+++ b/frontend/src/app/shared/test-connection-result-modal/test-connection-result-modal.component.html
@@ -12,6 +12,30 @@ <h4 class="modal-title" [translate]="type + '.test-connection.title'"></h4>
     } @else {
       @if (success) {
         <div class="alert alert-info" id="success" [translate]="type + '.test-connection.success'"></div>
+
+        @if (showAvailablePoints) {
+          <div class="mt-3">
+            <h5>Available Points:</h5>
+            <div class="table-responsive" style="max-height: 400px; overflow-y: auto">
+              <table class="table table-sm table-hover">
+                <thead>
+                  <tr>
+                    <th>Name</th>
+                    <th>Description</th>
+                  </tr>
+                </thead>
+                <tbody>
+                  @for (point of availablePoints; track point.id) {
+                    <tr>
+                      <td>{{ point.name }}</td>
+                      <td>{{ point.description || point.path || '-' }}</td>
+                    </tr>
+                  }
+                </tbody>
+              </table>
+            </div>
+          </div>
+        }
       }
     }
   } @else {
diff --git a/frontend/src/app/shared/test-connection-result-modal/test-connection-result-modal.component.ts b/frontend/src/app/shared/test-connection-result-modal/test-connection-result-modal.component.ts
index 63afda3fff..c116d1233e 100644
--- a/frontend/src/app/shared/test-connection-result-modal/test-connection-result-modal.component.ts
+++ b/frontend/src/app/shared/test-connection-result-modal/test-connection-result-modal.component.ts
@@ -1,7 +1,7 @@
 import { Component, inject } from '@angular/core';
 import { NgbActiveModal } from '@ng-bootstrap/ng-bootstrap';
 import { TranslateDirective } from '@ngx-translate/core';
-import { SouthConnectorCommandDTO, SouthConnectorDTO } from '../../../../../backend/shared/model/south-connector.model';
+import { SouthConnectorCommandDTO, SouthConnectorDTO, AvailablePoint } from '../../../../../backend/shared/model/south-connector.model';
 
 import { SouthConnectorService } from '../../services/south-connector.service';
 import { NorthConnectorCommandDTO, NorthConnectorDTO } from '../../../../../backend/shared/model/north-connector.model';
@@ -27,6 +27,8 @@ export class TestConnectionResultModalComponent {
   success = false;
   error: string | null = null;
   connector: SouthConnectorDTO<SouthSettings, SouthItemSettings> | NorthConnectorDTO<NorthSettings> | null = null;
+  availablePoints: Array<AvailablePoint> = [];
+  showAvailablePoints = false;
 
   /**
    * Prepares the component for creation.
@@ -56,6 +58,29 @@ export class TestConnectionResultModalComponent {
       next: () => {
         this.success = true;
         this.loading = false;
+
+        // If this is a PI Web API connector, also try to browse available points
+        if (this.type === 'south') {
+          const southCommand = command as SouthConnectorCommandDTO<SouthSettings, SouthItemSettings>;
+          if (southCommand.type === 'osisoft-pi-webapi') {
+            this.browseAvailablePoints(southCommand);
+          }
+        }
+      }
+    });
+  }
+
+  /**
+   * Browse available points for connectors that support it (like PI Web API)
+   */
+  browseAvailablePoints(command: SouthConnectorCommandDTO<SouthSettings, SouthItemSettings>) {
+    this.southConnectorService.browseAvailableItems(this.connector?.id || 'create', command).subscribe({
+      error: () => {
+        // Don't show error for browse points, just ignore it silently
+      },
+      next: (points: Array<AvailablePoint>) => {
+        this.availablePoints = points;
+        this.showAvailablePoints = points.length > 0;
       }
     });
   }
@@ -100,4 +125,8 @@ export class TestConnectionResultModalComponent {
   cancel() {
     this.modal.dismiss();
   }
+
+  selectPoint(point: AvailablePoint) {
+    this.modal.close(point);
+  }
 }
diff --git a/frontend/src/app/south/edit-south-item-modal/edit-south-item-modal.component.html b/frontend/src/app/south/edit-south-item-modal/edit-south-item-modal.component.html
index 099cc5331f..ffbac123c5 100644
--- a/frontend/src/app/south/edit-south-item-modal/edit-south-item-modal.component.html
+++ b/frontend/src/app/south/edit-south-item-modal/edit-south-item-modal.component.html
@@ -41,11 +41,99 @@ <h4 class="modal-title" [translate]="'south.edit-item-modal.' + mode + '-title'"
       @if (southItemRows.length > 0) {
         <oib-form [parentForm]="form" [form]="form.controls.settings" [settingsSchema]="southItemRows" [scanModes]="scanModes" />
       }
+
+      <!-- Browse Items Section (only for PI Web API) -->
+      @if (southManifest.id === 'osisoft-pi-webapi') {
+        <div class="row mt-4">
+          <div class="col-12">
+            <h5 translate="south.items.browse-items.title"></h5>
+            <div class="mb-3">
+              <div class="row">
+                <div class="col-6">
+                  <input
+                    type="text"
+                    class="form-control"
+                    [(ngModel)]="nameFilter"
+                    [ngModelOptions]="{ standalone: true }"
+                    [placeholder]="'south.items.browse-items.name-filter-placeholder' | translate"
+                  />
+                </div>
+                <div class="col-3">
+                  <button type="button" class="btn btn-primary" (click)="browseItems()" [disabled]="browsingItems">
+                    @if (browsingItems) {
+                      <span class="spinner-border spinner-border-sm me-2"></span>
+                    }
+                    <span translate="south.items.browse-items.browse-button"></span>
+                  </button>
+                </div>
+                <div class="col-3">
+                  @if (availablePoints.length > 0) {
+                    <button type="button" class="btn btn-success" (click)="selectAllItems()">
+                      <span translate="south.items.browse-items.select-all"></span>
+                    </button>
+                  }
+                </div>
+              </div>
+            </div>
+
+            @if (availablePoints.length > 0) {
+              <div class="table-responsive" style="max-height: 300px; overflow-y: auto">
+                <table class="table table-striped table-sm">
+                  <thead class="sticky-top" style="background: white">
+                    <tr>
+                      <th translate="south.items.browse-items.name"></th>
+                      <th translate="south.items.browse-items.description"></th>
+                      <th translate="south.items.browse-items.action"></th>
+                    </tr>
+                  </thead>
+                  <tbody>
+                    @for (point of availablePoints; track point.id) {
+                      <tr>
+                        <td>{{ point.name }}</td>
+                        <td>{{ point.description || point.path || '-' }}</td>
+                        <td>
+                          <button
+                            class="btn btn-sm btn-primary"
+                            (click)="selectPoint(point)"
+                            type="button"
+                            translate="south.items.browse-items.select"
+                          ></button>
+                        </td>
+                      </tr>
+                    }
+                  </tbody>
+                </table>
+              </div>
+            }
+
+            @if (browseError) {
+              <div class="alert alert-danger mt-2">
+                {{ browseError }}
+              </div>
+            }
+
+            @if (batchSelectionMessage) {
+              <div class="alert alert-success mt-2 d-flex justify-content-between align-items-center">
+                <span>{{ batchSelectionMessage }}</span>
+                <button type="button" class="btn btn-sm btn-outline-secondary" (click)="clearBatchSelection()">
+                  <span translate="south.items.browse-items.clear-selection"></span>
+                </button>
+              </div>
+            }
+          </div>
+        </div>
+      }
     </form>
+    @if (isBatchMode) {
+      <div class="alert alert-info mt-3">
+        <strong translate="south.items.batch-mode.title"></strong>
+        <p translate="south.items.batch-mode.test-description"></p>
+      </div>
+    }
     <oib-south-item-test
       type="south"
       [entityId]="southId"
-      [item]="formItem"
+      [item]="testableItem"
       [connectorCommand]="southConnectorCommand"
       [manifest]="southManifest"
     />
diff --git a/frontend/src/app/south/edit-south-item-modal/edit-south-item-modal.component.ts b/frontend/src/app/south/edit-south-item-modal/edit-south-item-modal.component.ts
index 548072d09a..3331bb2db2 100644
--- a/frontend/src/app/south/edit-south-item-modal/edit-south-item-modal.component.ts
+++ b/frontend/src/app/south/edit-south-item-modal/edit-south-item-modal.component.ts
@@ -10,7 +10,8 @@ import {
   SouthConnectorItemCommandDTO,
   SouthConnectorItemDTO,
   SouthConnectorItemManifest,
-  SouthConnectorManifest
+  SouthConnectorManifest,
+  AvailablePoint
 } from '../../../../../backend/shared/model/south-connector.model';
 import { ScanModeDTO } from '../../../../../backend/shared/model/scan-mode.model';
 
@@ -23,6 +24,8 @@ import { FormComponent } from '../../shared/form/form.component';
 import { SouthItemSettings, SouthSettings } from '../../../../../backend/shared/model/south-settings.model';
 import { SouthItemTestComponent } from '../south-item-test/south-item-test.component';
 import { UnsavedChangesConfirmationService } from '../../shared/unsaved-changes-confirmation.service';
+import { SouthConnectorService } from '../../services/south-connector.service';
+import { FormsModule } from '@angular/forms';
 
 // TypeScript issue with Intl: https://github.com/microsoft/TypeScript/issues/49231
 // eslint-disable-next-line @typescript-eslint/no-namespace
@@ -43,13 +46,15 @@ declare namespace Intl {
     OibScanModeComponent,
     FormComponent,
     SouthItemTestComponent,
-    TranslatePipe
+    TranslatePipe,
+    FormsModule
   ]
 })
 export class EditSouthItemModalComponent {
   private modal = inject(NgbActiveModal);
   private fb = inject(NonNullableFormBuilder);
   private unsavedChangesConfirmation = inject(UnsavedChangesConfirmationService);
+  private southConnectorService = inject(SouthConnectorService);
 
   mode: 'create' | 'edit' | 'copy' = 'create';
   state = new ObservableState();
@@ -77,6 +82,15 @@ export class EditSouthItemModalComponent {
     settings: FormGroup;
   }> | null = null;
 
+  // Browse items functionality
+  availablePoints: Array<AvailablePoint> = [];
+  browsingItems = false;
+  browseError: string | null = null;
+  nameFilter = '*';
+  selectedPoint: AvailablePoint | null = null;
+  selectedPointsForBatch: Array<SouthConnectorItemCommandDTO<SouthItemSettings>> = [];
+  batchSelectionMessage: string | null = null;
+
   private timezones: ReadonlyArray<Timezone> = Intl.supportedValuesOf('timeZone');
   timezoneTypeahead: (text$: Observable<string>) => Observable<Array<Timezone>> = inMemoryTypeahead(
     () => ['UTC', ...this.timezones],
@@ -245,6 +259,13 @@ export class EditSouthItemModalComponent {
   }
 
   save() {
+    // In batch mode, we don't need the form to be valid since we're using pre-built batch items
+    if (this.selectedPointsForBatch.length > 0) {
+      this.modal.close({ selectAll: true, items: this.selectedPointsForBatch });
+      return;
+    }
+
+    // For single items, validate the form
     if (!this.form!.valid) {
       return;
     }
@@ -252,6 +273,32 @@ export class EditSouthItemModalComponent {
     this.modal.close(this.formItem);
   }
 
+  get isBatchMode(): boolean {
+    return this.selectedPointsForBatch.length > 0;
+  }
+
+  get testableItem(): SouthConnectorItemCommandDTO<SouthItemSettings> {
+    // In batch mode, create a test item using the first selected point but with current form settings
+    if (this.isBatchMode && this.selectedPointsForBatch.length > 0) {
+      const formValue = this.form!.value;
+      const firstBatchItem = this.selectedPointsForBatch[0];
+
+      return {
+        id: null,
+        enabled: formValue.enabled!,
+        name: firstBatchItem.name,
+        scanModeId: firstBatchItem.scanModeId!,
+        scanModeName: null,
+        settings: {
+          ...formValue.settings!,
+          ...(firstBatchItem.settings as any)
+        }
+      };
+    }
+    // Otherwise, use the current form item
+    return this.formItem;
+  }
+
   get formItem(): SouthConnectorItemCommandDTO<SouthItemSettings> {
     const formValue = this.form!.value;
     let id: string | null = null;
@@ -259,13 +306,109 @@ export class EditSouthItemModalComponent {
       id = this.item?.id || null;
     }
 
+    const settings = { ...formValue.settings! };
+
+    // For PI Web API, add the selected point's webId
+    if (this.southManifest?.id === 'osisoft-pi-webapi' && this.selectedPoint) {
+      settings.pointWebId = this.selectedPoint.webId || this.selectedPoint.id;
+    }
+
     return {
       id,
       enabled: formValue.enabled!,
       name: formValue.name!,
       scanModeId: this.southItemSchema!.scanMode === 'SUBSCRIPTION' ? 'subscription' : formValue.scanModeId!,
       scanModeName: null,
-      settings: formValue.settings!
+      settings
     };
   }
+
+  // Browse items functionality
+  browseItems() {
+    if (!this.southConnectorCommand) {
+      return;
+    }
+
+    this.browsingItems = true;
+    this.browseError = null;
+    this.availablePoints = [];
+
+    const params = {
+      nameFilter: this.nameFilter,
+      maxPoints: 1000
+    };
+
+    this.southConnectorService.browseAvailableItems(this.southId, this.southConnectorCommand, params).subscribe({
+      next: (points: Array<AvailablePoint>) => {
+        this.availablePoints = points;
+        this.browsingItems = false;
+      },
+      error: error => {
+        this.browseError = error.error?.message || error.message || 'Failed to browse available items';
+        this.browsingItems = false;
+      }
+    });
+  }
+
+  selectPoint(point: AvailablePoint) {
+    // Store the selected point for later use
+    this.selectedPoint = point;
+
+    // Use setTimeout to ensure form controls are fully initialized
+    setTimeout(() => {
+      // Check if form is initialized before accessing controls
+      if (!this.form) {
+        return;
+      }
+
+      // Set the name to the point name
+      const nameControl = this.form.get('name');
+      if (nameControl) {
+        nameControl.setValue(point.name);
+      }
+
+      // Update the form settings to include the pointWebId
+      const settingsControl = this.form.get('settings');
+      if (settingsControl) {
+        const currentSettings = settingsControl.value || {};
+        settingsControl.setValue({
+          ...currentSettings,
+          pointWebId: point.webId || point.id
+        });
+        settingsControl.markAsDirty();
+      }
+    }, 0);
+  }
+
+  selectAllItems() {
+    if (this.availablePoints.length === 0) {
+      return;
+    }
+
+    // Get current form values to use for all batch items
+    const formValue = this.form!.value;
+    const defaultScanModeId = this.southItemSchema!.scanMode === 'SUBSCRIPTION' ? 'subscription' : formValue.scanModeId || 'subscription';
+
+    // Store all points for batch creation
+    this.selectedPointsForBatch = this.availablePoints.map(point => ({
+      id: null,
+      enabled: formValue.enabled || true,
+      name: point.name,
+      scanModeId: defaultScanModeId,
+      scanModeName: null,
+      settings: {
+        ...formValue.settings!,
+        pointWebId: point.webId || point.id
+      } as any
+    }));
+
+    // Show confirmation message
+    this.batchSelectionMessage = `Selected ${this.availablePoints.length} items for batch creation. You can save to add all items, or clear selection to test individual items.`;
+  }
+
+  clearBatchSelection() {
+    this.selectedPointsForBatch = [];
+    this.batchSelectionMessage = '';
+    this.selectedPoint = null;
+  }
 }
diff --git a/frontend/src/app/south/edit-south/edit-south.component.ts b/frontend/src/app/south/edit-south/edit-south.component.ts
index 2e581dbdd8..0ce0849576 100644
--- a/frontend/src/app/south/edit-south/edit-south.component.ts
+++ b/frontend/src/app/south/edit-south/edit-south.component.ts
@@ -2,6 +2,7 @@ import { Component, OnInit, inject } from '@angular/core';
 
 import { TranslateDirective } from '@ngx-translate/core';
 import {
+  AvailablePoint,
   OIBusSouthType,
   SouthConnectorCommandDTO,
   SouthConnectorDTO,
@@ -194,6 +195,25 @@ export class EditSouthComponent implements OnInit, CanComponentDeactivate {
       const modalRef = this.modalService.open(TestConnectionResultModalComponent);
       const component: TestConnectionResultModalComponent = modalRef.componentInstance;
       component.runTest('south', this.southConnector, this.formSouthConnectorCommand);
+
+      // Handle point selection for PI Web API connectors
+      modalRef.result.subscribe({
+        next: (selectedPoint: AvailablePoint) => {
+          if (selectedPoint && this.formSouthConnectorCommand.type === 'osisoft-pi-webapi') {
+            // Navigate to add new item with pre-filled data
+            this.router.navigate(['south-items', 'create'], {
+              relativeTo: this.route,
+              queryParams: {
+                pointName: selectedPoint.name,
+                webId: selectedPoint['webId'] || selectedPoint.id
+              }
+            });
+          }
+        },
+        error: () => {
+          // Modal was dismissed, do nothing
+        }
+      });
     }
   }
 
diff --git a/frontend/src/app/south/south-item-test/item-test-result/item-test-table-result/item-test-table-result.component.html b/frontend/src/app/south/south-item-test/item-test-result/item-test-table-result/item-test-table-result.component.html
index a7fb15eafa..6f0be1cd7a 100644
--- a/frontend/src/app/south/south-item-test/item-test-result/item-test-table-result/item-test-table-result.component.html
+++ b/frontend/src/app/south/south-item-test/item-test-result/item-test-table-result/item-test-table-result.component.html
@@ -10,7 +10,9 @@
       @for (item of tableView.content; track $index) {
         <div class="grid-table-row">
           <div class="align-items-center d-flex h-100 p-2">{{ item.timestamp }}</div>
-          <div class="align-items-center d-flex h-100 p-2">{{ item.pointId }}</div>
+          <div class="align-items-center d-flex h-100 p-2">
+            <oib-truncated-string [string]="item.pointId" [maxLength]="30" />
+          </div>
           <div class="align-items-center d-flex h-100 p-2" style="overflow-wrap: anywhere">{{ convertDataToString(item.data).value }}</div>
           <div class="align-items-center d-flex h-100 p-2">
             <code class="json-content">{{ convertDataToString(item.data).other }}</code>
diff --git a/frontend/src/app/south/south-item-test/item-test-result/item-test-table-result/item-test-table-result.component.ts b/frontend/src/app/south/south-item-test/item-test-result/item-test-table-result/item-test-table-result.component.ts
index 3255d12ea7..e29eb093c8 100644
--- a/frontend/src/app/south/south-item-test/item-test-result/item-test-table-result/item-test-table-result.component.ts
+++ b/frontend/src/app/south/south-item-test/item-test-result/item-test-table-result/item-test-table-result.component.ts
@@ -6,13 +6,14 @@ import { emptyPage } from '../../../../shared/test-utils';
 import { PaginationComponent } from '../../../../shared/pagination/pagination.component';
 import { TranslatePipe } from '@ngx-translate/core';
 import { BaseItemTestResult } from '../item-test-result.interface';
+import { TruncatedStringComponent } from '../../../../shared/truncated-string/truncated-string.component';
 import Papa from 'papaparse';
 
 const PAGE_SIZE = 10;
 
 @Component({
   selector: 'oib-item-test-table-result',
-  imports: [PaginationComponent, TranslatePipe],
+  imports: [PaginationComponent, TranslatePipe, TruncatedStringComponent],
   templateUrl: './item-test-table-result.component.html',
   styleUrl: './item-test-table-result.component.scss'
 })
diff --git a/frontend/src/app/south/south-items/south-items.component.ts b/frontend/src/app/south/south-items/south-items.component.ts
index 57ebf09b79..0cb3c8f0c0 100644
--- a/frontend/src/app/south/south-items/south-items.component.ts
+++ b/frontend/src/app/south/south-items/south-items.component.ts
@@ -14,7 +14,7 @@ import {
   SouthConnectorManifest
 } from '../../../../../backend/shared/model/south-connector.model';
 import { EditSouthItemModalComponent } from '../edit-south-item-modal/edit-south-item-modal.component';
-import { debounceTime, distinctUntilChanged, firstValueFrom, of, switchMap, tap } from 'rxjs';
+import { debounceTime, distinctUntilChanged, firstValueFrom, of, switchMap, tap, forkJoin } from 'rxjs';
 import { BoxComponent, BoxTitleDirective } from '../../shared/box/box.component';
 import { ScanModeDTO } from '../../../../../backend/shared/model/scan-mode.model';
 import { OibFormControl } from '../../../../../backend/shared/model/form.model';
@@ -195,21 +195,51 @@ export class SouthItemsComponent implements OnInit {
   private refreshAfterCreationModalClosed(modalRef: Modal<any>) {
     modalRef.result
       .pipe(
-        switchMap((command: SouthConnectorItemCommandDTO<SouthItemSettings>) => {
-          if (this.saveChangesDirectly()) {
-            return this.southConnectorService.createItem(this.southId(), command);
-          } else {
-            this.allItems.push({
-              id: command.id ?? null,
-              name: command.name,
-              enabled: command.enabled,
-              scanModeId: command.scanModeId!,
-              scanModeName: null,
-              settings: { ...command.settings }
-            });
-            return of(null);
+        switchMap(
+          (
+            result:
+              | SouthConnectorItemCommandDTO<SouthItemSettings>
+              | { selectAll: boolean; items: Array<SouthConnectorItemCommandDTO<SouthItemSettings>> }
+          ) => {
+            // Handle "select all" response
+            if ('selectAll' in result && result.selectAll) {
+              if (this.saveChangesDirectly()) {
+                // Create all items via API
+                const createRequests = result.items.map(item => this.southConnectorService.createItem(this.southId(), item));
+                return forkJoin(createRequests);
+              } else {
+                // Add all items to local array
+                result.items.forEach(command => {
+                  this.allItems.push({
+                    id: command.id ?? null,
+                    name: command.name,
+                    enabled: command.enabled,
+                    scanModeId: command.scanModeId!,
+                    scanModeName: null,
+                    settings: { ...command.settings }
+                  });
+                });
+                return of(null);
+              }
+            } else {
+              // Handle single item response
+              const command = result as SouthConnectorItemCommandDTO<SouthItemSettings>;
+              if (this.saveChangesDirectly()) {
+                return this.southConnectorService.createItem(this.southId(), command);
+              } else {
+                this.allItems.push({
+                  id: command.id ?? null,
+                  name: command.name,
+                  enabled: command.enabled,
+                  scanModeId: command.scanModeId!,
+                  scanModeName: null,
+                  settings: { ...command.settings }
+                });
+                return of(null);
+              }
+            }
           }
-        })
+        )
       )
       .subscribe(() => {
         if (this.saveChangesDirectly()) {
diff --git a/frontend/src/i18n/en.json b/frontend/src/i18n/en.json
index 1ae5800a85..7d5423b01c 100644
--- a/frontend/src/i18n/en.json
+++ b/frontend/src/i18n/en.json
@@ -234,6 +234,7 @@
       "opcua": "OPC UA™",
       "oracle": "Oracle Database™",
       "osisoft-pi": "OSIsoft PI System™",
+      "osisoft-pi-webapi": "OSIsoft PI Web API™",
       "postgresql": "PostgreSQL",
       "sftp": "SFTP",
       "sqlite": "SQLite™"
@@ -252,6 +253,7 @@
       "opcua": "Query data from OPC UA™ server (HA/DA)",
       "oracle": "Query data from an Oracle Database™",
       "osisoft-pi": "Establish a connection with an OIBus Agent to access data from a PI System™",
+      "osisoft-pi-webapi": "Connect directly to OSIsoft PI Web API™ to retrieve historical data",
       "postgresql": "Query PostgreSQL databases",
       "sftp": "Read files from a remote SFTP server",
       "sqlite": "Query  SQLite™ databases"
@@ -890,6 +892,23 @@
       "agent-url": "Remote agent URL",
       "retry-interval": "Retry interval"
     },
+    "osisoft-pi-webapi": {
+      "throttling": {
+        "title": "Throttling",
+        "max-read-interval": "Max read interval",
+        "read-delay": "Read delay",
+        "overlap": "Overlap",
+        "max-instant-per-item": "Max instant per item"
+      },
+      "url": "PI Web API URL",
+      "data-server-web-id": "Data Server WebID",
+      "username": "Username",
+      "password": "Password",
+      "accept-unauthorized": "Accept unauthorized certificates",
+      "timeout": "Timeout",
+      "retry-interval": "Retry interval",
+      "point-web-id": "PI Point Web ID"
+    },
     "postgresql": {
       "throttling": {
         "title": "Throttling",
@@ -954,6 +973,21 @@
       "search-placeholder": "Enter text to filter items",
       "save-before-adding-items": "Save connector before you can add new items",
       "name": "Name",
+      "browse-items": {
+        "title": "Browse Available Items",
+        "name-filter-placeholder": "Filter by name (use * for all)",
+        "browse-button": "Browse Items",
+        "select-all": "Select All",
+        "clear-selection": "Clear Selection",
+        "name": "Name",
+        "description": "Description",
+        "action": "Action",
+        "select": "Select"
+      },
+      "batch-mode": {
+        "title": "Batch Creation Mode",
+        "test-description": "You have selected multiple items for batch creation. Testing will use the first selected item as a sample."
+      },
       "enable": "Enabled",
       "confirm-deletion": "Are you sure you want to delete this South connector item?",
       "confirm-delete-all": "Are you sure you want to delete all this South connector items?",
@@ -1377,6 +1411,10 @@
         "pi-point": "PI point",
         "pi-query": "PI query"
       },
+      "osisoft-pi-webapi": {
+        "web-id": "Web ID",
+        "pi-point": "PI point name"
+      },
       "postgresql": {
         "query": "Query",
         "date-time-fields": {