diff --git a/CHANGELOG.md b/CHANGELOG.md
index 9eadcf7fd0..ecb2035e39 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -55,6 +55,8 @@ Main (unreleased)
 
 - Add `file_match` block to `loki.source.file` for built-in file discovery using glob patterns. (@kalleep)
 
+- Add `prometheus.exporter.ipmi` component to collect hardware metrics from IPMI-enabled devices. Supports both local IPMI collection and remote IPMI monitoring with authentication. (@parsa97)
+
 ### Enhancements
 
 - Add support of `tls` in components `loki.source.(awsfirehose|gcplog|heroku|api)` and `prometheus.receive_http` and `pyroscope.receive_http`. (@fgouteroux)
diff --git a/docs/sources/reference/components/prometheus/prometheus.exporter.ipmi.md b/docs/sources/reference/components/prometheus/prometheus.exporter.ipmi.md
new file mode 100644
index 0000000000..fdda128363
--- /dev/null
+++ b/docs/sources/reference/components/prometheus/prometheus.exporter.ipmi.md
@@ -0,0 +1,363 @@
+---
+canonical: https://grafana.com/docs/alloy/latest/reference/components/prometheus/prometheus.exporter.ipmi/
+aliases:
+  - ../prometheus.exporter.ipmi/ # /docs/alloy/latest/reference/components/prometheus.exporter.ipmi/
+description: Learn about prometheus.exporter.ipmi
+labels:
+  stage: general-availability
+  products:
+    - oss
+title: prometheus.exporter.ipmi
+---
+
+# `prometheus.exporter.ipmi`
+
+The `prometheus.exporter.ipmi` component collects hardware metrics from IPMI-enabled devices.
+It supports both local IPMI collection (from the machine running Alloy) and remote IPMI collection from network-accessible devices.
+
+## Usage
+
+```alloy
+prometheus.exporter.ipmi "<LABEL>" {
+  target {
+    name    = "<NAME>"
+    address = "<IPMI_ADDRESS>"
+    user    = "<USERNAME>"
+    password = "<PASSWORD>"
+  }
+}
+```
+
+## Arguments
+
+You can use the following arguments with `prometheus.exporter.ipmi`:
+
+| Name          | Type       | Description                                           | Default | Required |
+| ------------- | ---------- | ----------------------------------------------------- | ------- | -------- |
+| `timeout`     | `duration` | Timeout for IPMI requests.                            | `"30s"` | no       |
+| `config_file` | `string`   | Path to IPMI exporter configuration file.            |         | no       |
+| `ipmi_config` | `string`   | IPMI exporter configuration as inline YAML string.    |         | no       |
+
+The `timeout` should be set high enough to allow IPMI sensor collection to complete.
+IPMI operations can be slow, especially for devices with many sensors.
+A timeout of 30 seconds or more is recommended for most hardware.
+
+The `config_file` and `ipmi_config` arguments are mutually exclusive.
+They allow advanced configuration of IPMI collection modules and command overrides.
+
+## Blocks
+
+You can use the following blocks with `prometheus.exporter.ipmi`:
+
+| Name             | Description                          | Required |
+| ---------------- | ------------------------------------ | -------- |
+| [`target`][target] | Configures a remote IPMI target.     | no       |
+| [`local`][local]   | Configures local IPMI collection.    | no       |
+
+At least one `target` block or the `local` block must be configured.
+
+[target]: #target
+[local]: #local
+
+### `target`
+
+| Name        | Type     | Description                                   | Default     | Required |
+| ----------- | -------- | --------------------------------------------- | ----------- | -------- |
+| `name`      | `string` | Name of the target (used in job label).      |             | yes      |
+| `address`   | `string` | IP address or hostname of the IPMI device.    |             | yes      |
+| `user`      | `string` | IPMI username for authentication.             |             | no       |
+| `password`  | `secret` | IPMI password for authentication.             |             | no       |
+| `driver`    | `string` | IPMI driver to use (`LAN_2_0` or `LAN`).      | `"LAN_2_0"` | no       |
+| `privilege` | `string` | IPMI privilege level (`user` or `admin`).    | `"admin"`   | no       |
+| `module`    | `string` | IPMI collector module to use.                 |             | no       |
+
+The `target` block defines a remote IPMI device to monitor.
+Multiple `target` blocks can be specified to monitor multiple devices.
+
+The `driver` attribute specifies which IPMI protocol version to use:
+- `LAN_2_0`: IPMI 2.0 protocol (recommended for most modern hardware)
+- `LAN`: IPMI 1.5 protocol (for older hardware)
+
+The `privilege` attribute sets the privilege level for IPMI operations:
+- `admin`: Full administrative access (required for all sensor data on most hardware)
+- `user`: User-level access (limited sensor access)
+
+### `local`
+
+| Name      | Type     | Description                              | Default | Required |
+| --------- | -------- | ---------------------------------------- | ------- | -------- |
+| `enabled` | `bool`   | Enable local IPMI collection.            | `false` | no       |
+| `module`  | `string` | IPMI collector module to use.            |         | no       |
+
+The `local` block enables collection from the local machine's IPMI interface.
+This requires the machine to have IPMI hardware and appropriate permissions.
+On Linux systems, this typically requires:
+- FreeIPMI tools installed
+- Kernel modules loaded (`ipmi_devintf`, `ipmi_si`)
+- Appropriate device permissions (`/dev/ipmi0`)
+
+## Exported fields
+
+{{< docs/shared lookup="reference/components/exporter-component-exports.md" source="alloy" version="<ALLOY_VERSION>" >}}
+
+## Component health
+
+`prometheus.exporter.ipmi` is only reported as unhealthy if given an invalid configuration.
+In those cases, exported fields retain their last healthy values.
+
+IPMI connection failures or timeouts don't affect component health.
+Instead, the `ipmi_up` metric is set to 0 for unreachable targets.
+
+## Debug information
+
+`prometheus.exporter.ipmi` doesn't expose any component-specific debug information.
+
+## Debug metrics
+
+`prometheus.exporter.ipmi` doesn't expose any component-specific debug metrics.
+
+## Collected metrics
+
+The IPMI exporter collects the following metrics:
+
+| Metric                      | Type  | Description                                                       |
+| --------------------------- | ----- | ----------------------------------------------------------------- |
+| `ipmi_up`                   | Gauge | IPMI device reachability (1=up, 0=down)                           |
+| `ipmi_temperature_celsius`  | Gauge | Temperature sensor reading in degrees Celsius                     |
+| `ipmi_fan_speed_rpm`        | Gauge | Fan speed sensor reading in RPM                                   |
+| `ipmi_voltage_volts`        | Gauge | Voltage sensor reading in volts                                   |
+| `ipmi_power_watts`          | Gauge | Power sensor reading in watts                                     |
+| `ipmi_current_amperes`      | Gauge | Current sensor reading in amperes                                 |
+| `ipmi_sensor_state`         | Gauge | Sensor state (0=nominal, 1=warning, 2=critical, 3=not available)  |
+| `ipmi_collector_info`       | Gauge | Information about the IPMI collector configuration               |
+
+All sensor metrics include labels:
+- `target`: IP address or "localhost" for local collection
+- `sensor`: Sensor name from IPMI hardware
+- `id`: Sensor ID number
+
+## Examples
+
+### Monitor remote IPMI devices
+
+This example monitors two remote servers via IPMI and forwards metrics to Prometheus:
+
+```alloy
+prometheus.exporter.ipmi "servers" {
+  target {
+    name      = "server-01"
+    address   = "192.168.1.10"
+    user      = "monitoring"
+    password  = env("IPMI_PASSWORD")
+    driver    = "LAN_2_0"
+    privilege = "admin"
+  }
+
+  target {
+    name      = "server-02"
+    address   = "192.168.1.11"
+    user      = "monitoring"
+    password  = env("IPMI_PASSWORD")
+    driver    = "LAN_2_0"
+    privilege = "admin"
+  }
+
+  timeout = "30s"
+}
+
+prometheus.scrape "ipmi" {
+  targets         = prometheus.exporter.ipmi.servers.targets
+  forward_to      = [prometheus.remote_write.default.receiver]
+  scrape_interval = "60s"
+  scrape_timeout  = "45s"
+}
+
+prometheus.remote_write "default" {
+  endpoint {
+    url = "http://prometheus:9090/api/v1/write"
+  }
+}
+```
+
+### Monitor local IPMI device
+
+This example monitors the local server's IPMI interface:
+
+```alloy
+prometheus.exporter.ipmi "local_server" {
+  local {
+    enabled = true
+    module  = "default"
+  }
+}
+
+prometheus.scrape "ipmi_local" {
+  targets    = prometheus.exporter.ipmi.local_server.targets
+  forward_to = [prometheus.remote_write.default.receiver]
+}
+
+prometheus.remote_write "default" {
+  endpoint {
+    url = "http://prometheus:9090/api/v1/write"
+  }
+}
+```
+
+### Monitor both local and remote devices
+
+This example combines local and remote IPMI monitoring:
+
+```alloy
+prometheus.exporter.ipmi "infrastructure" {
+  // Monitor local machine
+  local {
+    enabled = true
+  }
+
+  // Monitor remote servers
+  target {
+    name     = "compute-01"
+    address  = "10.0.1.10"
+    user     = "admin"
+    password = env("IPMI_PASSWORD")
+  }
+
+  target {
+    name     = "compute-02"
+    address  = "10.0.1.11"
+    user     = "admin"
+    password = env("IPMI_PASSWORD")
+  }
+
+  timeout = "30s"
+}
+
+prometheus.scrape "all_ipmi" {
+  targets         = prometheus.exporter.ipmi.infrastructure.targets
+  forward_to      = [prometheus.remote_write.default.receiver]
+  scrape_interval = "60s"
+  scrape_timeout  = "45s"
+}
+
+prometheus.remote_write "default" {
+  endpoint {
+    url = env("PROMETHEUS_URL")
+  }
+}
+```
+
+### Access metrics directly without scraping
+
+For testing or debugging, you can access IPMI metrics directly via HTTP:
+
+```alloy
+prometheus.exporter.ipmi "test" {
+  target {
+    name     = "test-server"
+    address  = "192.168.1.100"
+    user     = "monitoring"
+    password = env("IPMI_PASSWORD")
+  }
+}
+```
+
+Metrics are available at:
+```
+http://localhost:12345/api/v0/component/prometheus.exporter.ipmi.test/metrics
+```
+
+## Technical notes
+
+### IPMI timeout configuration
+
+IPMI sensor collection can be slow, especially for servers with many sensors.
+Configure timeouts appropriately:
+
+- **Component timeout**: Set to 30-60 seconds to allow sensor collection to complete
+- **Scrape timeout**: Must be longer than the component timeout
+- **Scrape interval**: Recommended 60 seconds or more to avoid overlapping collections
+
+Example configuration:
+```alloy
+prometheus.exporter.ipmi "servers" {
+  timeout = "30s"  // Allow 30 seconds for IPMI operations
+  // ... targets ...
+}
+
+prometheus.scrape "ipmi" {
+  scrape_interval = "60s"  // Scrape every minute
+  scrape_timeout  = "45s"  // Allow 45 seconds (> component timeout)
+  targets         = prometheus.exporter.ipmi.servers.targets
+  // ... forward_to ...
+}
+```
+
+### IPMI driver selection
+
+Choose the appropriate IPMI driver based on your hardware:
+
+- **LAN_2_0** (IPMI 2.0): Recommended for modern servers (Dell, HP, Supermicro from ~2010+)
+- **LAN** (IPMI 1.5): For older hardware that doesn't support IPMI 2.0
+
+If unsure, try `LAN_2_0` first. Connection failures may indicate the need to use `LAN`.
+
+### Local IPMI requirements
+
+For local IPMI collection, ensure:
+
+1. **Hardware support**: Server has BMC/IPMI hardware
+2. **Kernel modules** (Linux):
+   ```bash
+   modprobe ipmi_devintf
+   modprobe ipmi_si
+   ```
+3. **Device permissions**:
+   ```bash
+   ls -l /dev/ipmi* /dev/ipmi0
+   # Should be accessible by the user running Alloy
+   ```
+4. **FreeIPMI tools** (optional but recommended):
+   ```bash
+   # Debian/Ubuntu
+   apt-get install freeipmi-tools
+
+   # RHEL/CentOS
+   yum install freeipmi
+   ```
+
+### Security considerations
+
+IPMI credentials provide low-level hardware access:
+
+- **Use dedicated monitoring users** with minimal required privileges
+- **Store passwords securely** using `env()` or secrets management
+- **Never commit passwords** to version control
+- **Consider network isolation** for IPMI interfaces (dedicated management network)
+- **Use IPMI 2.0** (`LAN_2_0`) when possible for better security
+
+Example with environment variables:
+```alloy
+prometheus.exporter.ipmi "secure" {
+  target {
+    name     = "production-server"
+    address  = env("IPMI_HOST")
+    user     = env("IPMI_USER")
+    password = env("IPMI_PASSWORD")
+  }
+}
+```
+
+<!-- START GENERATED COMPATIBLE COMPONENTS -->
+
+## Compatible components
+
+`prometheus.exporter.ipmi` has exports that can be consumed by the following components:
+
+- Components that consume [Targets](../../../compatibility/#targets-consumers)
+
+{{< admonition type="note" >}}
+Connecting some components may not be sensible or components may require further configuration to make the connection work correctly.
+Refer to the linked documentation for more details.
+{{< /admonition >}}
+
+<!-- END GENERATED COMPATIBLE COMPONENTS -->
diff --git a/go.mod b/go.mod
index 428474b5e6..6bcdfeaad8 100644
--- a/go.mod
+++ b/go.mod
@@ -115,7 +115,7 @@ require (
 	github.com/natefinch/atomic v1.0.1
 	github.com/ncabatoff/process-exporter v0.8.7
 	github.com/oklog/run v1.2.0
-	github.com/olekukonko/tablewriter v0.0.5
+	github.com/olekukonko/tablewriter v1.0.9
 	github.com/oliver006/redis_exporter v1.74.0
 	github.com/open-telemetry/opentelemetry-collector-contrib/connector/servicegraphconnector v0.134.0
 	github.com/open-telemetry/opentelemetry-collector-contrib/connector/spanmetricsconnector v0.134.0
@@ -1001,6 +1001,13 @@ require (
 	github.com/open-telemetry/opentelemetry-collector-contrib/receiver/cloudflarereceiver v0.138.0 // indirect
 )
 
+require github.com/bougou/go-ipmi v0.7.7 // indirect
+
+require (
+	github.com/kr/pretty v0.3.1 // indirect
+	github.com/kr/text v0.2.0 // indirect
+)
+
 // NOTE: replace directives below must always be *temporary*.
 //
 // Adding a replace directive to change a module to a fork of a module will
@@ -1108,3 +1115,5 @@ replace github.com/deneonet/benc => github.com/deneonet/benc v1.1.7
 replace github.com/opencontainers/runc => github.com/opencontainers/runc v1.2.6
 
 replace sigs.k8s.io/controller-runtime => sigs.k8s.io/controller-runtime v0.20.4
+
+replace github.com/olekukonko/tablewriter => github.com/olekukonko/tablewriter v0.0.5
diff --git a/go.sum b/go.sum
index 871180923b..f155439d4d 100644
--- a/go.sum
+++ b/go.sum
@@ -597,6 +597,8 @@ github.com/bmatcuk/doublestar v1.3.4 h1:gPypJ5xD31uhX6Tf54sDPUOBXTqKH4c9aPY66CyQ
 github.com/bmatcuk/doublestar v1.3.4/go.mod h1:wiQtGV+rzVYxB7WIlirSN++5HPtPlXEo9MEoZQC/PmE=
 github.com/bmatcuk/doublestar/v4 v4.9.1 h1:X8jg9rRZmJd4yRy7ZeNDRnM+T3ZfHv15JiBJ/avrEXE=
 github.com/bmatcuk/doublestar/v4 v4.9.1/go.mod h1:xBQ8jztBU6kakFMg+8WGxn0c6z1fTSPVIjEY1Wr7jzc=
+github.com/bougou/go-ipmi v0.7.7 h1:QSdyGaYePBdUgIn0x2PP4K1BsPiNMEmzMwIwIN1p3S8=
+github.com/bougou/go-ipmi v0.7.7/go.mod h1:h3JPPoIK/caMQQJiW0BUtqYPcV8zkLobq1hnKwITlmk=
 github.com/boynux/squid-exporter v1.10.5-0.20230618153315-c1fae094e18e h1:C1vYe728vM2FpXaICJuDRt5zgGyRdMmUGYnVfM7WcLY=
 github.com/boynux/squid-exporter v1.10.5-0.20230618153315-c1fae094e18e/go.mod h1:8NpZERGK+R9DGuZqqsKfnf2qI/rh7yBT8End29IvgNA=
 github.com/briandowns/spinner v1.23.0 h1:alDF2guRWqa/FOZZYWjlMIx2L6H0wyewPxo/CH4Pt2A=
@@ -1741,7 +1743,6 @@ github.com/oklog/ulid v1.3.1 h1:EGfNDEx6MqHz8B3uNV6QAib1UR2Lm97sHi3ocA6ESJ4=
 github.com/oklog/ulid v1.3.1/go.mod h1:CirwcVhetQ6Lv90oh/F+FBtV6XMibvdAFo93nm5qn4U=
 github.com/oklog/ulid/v2 v2.1.1 h1:suPZ4ARWLOJLegGFiZZ1dFAkqzhMjL3J1TzI+5wHz8s=
 github.com/oklog/ulid/v2 v2.1.1/go.mod h1:rcEKHmBBKfef9DhnvX7y1HZBYxjXb0cP5ExxNsTT1QQ=
-github.com/olekukonko/tablewriter v0.0.0-20180130162743-b8a9be070da4/go.mod h1:vsDQFd/mU46D+Z4whnwzcISnGGzXWMclvtLoiIKAKIo=
 github.com/olekukonko/tablewriter v0.0.5 h1:P2Ga83D34wi1o9J6Wh1mRuqd4mF/x/lgBS7N7AbDhec=
 github.com/olekukonko/tablewriter v0.0.5/go.mod h1:hPp6KlRPjbx+hW8ykQs1w3UBbZlj6HuIJcUGPhkA7kY=
 github.com/oliver006/redis_exporter v1.74.0 h1:/ESQZa3xqpQxiQmk4tpo90Y8gPWLpYVF6E5SR262KtM=
@@ -2026,6 +2027,7 @@ github.com/pjbgf/sha1cd v0.3.2 h1:a9wb0bp1oC2TGwStyn0Umc/IGKQnEgF0vVaZ8QF8eo4=
 github.com/pjbgf/sha1cd v0.3.2/go.mod h1:zQWigSxVmsHEZow5qaLtPYxpcKMMQpa09ixqBxuCS6A=
 github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c h1:+mdjkGKdHQG3305AYmdv1U2eRNDiU2ErMBj1gwrq8eQ=
 github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c/go.mod h1:7rwL4CYBLnjLxUqIJNnCWiEdr3bn6IUYi15bNlnbCCU=
+github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA=
 github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
@@ -2150,6 +2152,7 @@ github.com/rogpeppe/fastuuid v0.0.0-20150106093220-6724a57986af/go.mod h1:XWv6So
 github.com/rogpeppe/fastuuid v1.2.0/go.mod h1:jVj6XXZzXRy/MSR5jhDC/2q6DgLz+nrA6LYCDYWNEvQ=
 github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
 github.com/rogpeppe/go-internal v1.6.1/go.mod h1:xXDCJY+GAPziupqXw64V24skbSoqbTEfhy4qGm1nDQc=
+github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs=
 github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ=
 github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc=
 github.com/rs/cors v1.11.1 h1:eU3gRzXLRK57F5rKMGMZURNdIG4EoAmX8k94r9wXWHA=
diff --git a/internal/component/all/all.go b/internal/component/all/all.go
index 201850ff90..658984d696 100644
--- a/internal/component/all/all.go
+++ b/internal/component/all/all.go
@@ -136,6 +136,7 @@ import (
 	_ "github.com/grafana/alloy/internal/component/prometheus/exporter/elasticsearch"        // Import prometheus.exporter.elasticsearch
 	_ "github.com/grafana/alloy/internal/component/prometheus/exporter/gcp"                  // Import prometheus.exporter.gcp
 	_ "github.com/grafana/alloy/internal/component/prometheus/exporter/github"               // Import prometheus.exporter.github
+	_ "github.com/grafana/alloy/internal/component/prometheus/exporter/ipmi"                 // Import prometheus.exporter.ipmi
 	_ "github.com/grafana/alloy/internal/component/prometheus/exporter/kafka"                // Import prometheus.exporter.kafka
 	_ "github.com/grafana/alloy/internal/component/prometheus/exporter/memcached"            // Import prometheus.exporter.memcached
 	_ "github.com/grafana/alloy/internal/component/prometheus/exporter/mongodb"              // Import prometheus.exporter.mongodb
diff --git a/internal/component/prometheus/exporter/ipmi/config.go b/internal/component/prometheus/exporter/ipmi/config.go
new file mode 100644
index 0000000000..11af613b4c
--- /dev/null
+++ b/internal/component/prometheus/exporter/ipmi/config.go
@@ -0,0 +1,99 @@
+package ipmi
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/grafana/alloy/internal/static/integrations/ipmi_exporter"
+	"github.com/grafana/alloy/internal/util"
+	"github.com/grafana/alloy/syntax/alloytypes"
+	config_util "github.com/prometheus/common/config"
+)
+
+// DefaultArguments holds non-zero default options for Arguments.
+var DefaultArguments = Arguments{
+	Timeout: 10 * time.Second,
+}
+
+// Arguments configures the prometheus.exporter.ipmi component.
+type Arguments struct {
+	// Local configures monitoring of the local machine's IPMI interface.
+	Local LocalConfig `alloy:"local,block,optional"`
+
+	// Targets to monitor via remote IPMI.
+	Targets []IPMITarget `alloy:"target,block,optional"`
+
+	// Timeout for IPMI requests.
+	Timeout time.Duration `alloy:"timeout,attr,optional"`
+
+	// ConfigFile points to an external ipmi_exporter configuration file.
+	ConfigFile string `alloy:"config_file,attr,optional"`
+
+	// IPMIConfig is the inline ipmi_exporter configuration.
+	IPMIConfig util.RawYAML `alloy:"ipmi_config,attr,optional"`
+}
+
+// LocalConfig controls local IPMI collection.
+type LocalConfig struct {
+	// Enabled controls whether local IPMI collection is enabled.
+	Enabled bool `alloy:"enabled,attr,optional"`
+
+	// Module specifies which collector module to use for local collection.
+	Module string `alloy:"module,attr,optional"`
+}
+
+// IPMITarget defines a target device to be monitored.
+type IPMITarget struct {
+	Name   string `alloy:"name,attr"`
+	Target string `alloy:"address,attr"`
+	Module string `alloy:"module,attr,optional"`
+
+	// Authentication for remote IPMI
+	User      string            `alloy:"user,attr,optional"`
+	Password  alloytypes.Secret `alloy:"password,attr,optional"`
+	Driver    string            `alloy:"driver,attr,optional"`    // LAN_2_0 or LAN
+	Privilege string            `alloy:"privilege,attr,optional"` // user or admin
+}
+
+// SetToDefault implements syntax.Defaulter.
+func (a *Arguments) SetToDefault() {
+	*a = DefaultArguments
+}
+
+// Validate implements syntax.Validator.
+func (a *Arguments) Validate() error {
+	if !a.Local.Enabled && len(a.Targets) == 0 {
+		return fmt.Errorf("either local IPMI collection must be enabled or at least one remote target must be configured")
+	}
+	return nil
+}
+
+// Convert converts the component's Arguments to the integration's Config.
+func (a *Arguments) Convert() *ipmi_exporter.Config {
+	return &ipmi_exporter.Config{
+		Local: ipmi_exporter.LocalConfig{
+			Enabled: a.Local.Enabled,
+			Module:  a.Local.Module,
+		},
+		Targets:    convertTargets(a.Targets),
+		Timeout:    a.Timeout.Milliseconds(),
+		ConfigFile: a.ConfigFile,
+		IPMIConfig: a.IPMIConfig,
+	}
+}
+
+func convertTargets(targets []IPMITarget) []ipmi_exporter.IPMITarget {
+	result := make([]ipmi_exporter.IPMITarget, 0, len(targets))
+	for _, t := range targets {
+		result = append(result, ipmi_exporter.IPMITarget{
+			Name:      t.Name,
+			Target:    t.Target,
+			Module:    t.Module,
+			User:      t.User,
+			Password:  config_util.Secret(t.Password),
+			Driver:    t.Driver,
+			Privilege: t.Privilege,
+		})
+	}
+	return result
+}
diff --git a/internal/component/prometheus/exporter/ipmi/ipmi.go b/internal/component/prometheus/exporter/ipmi/ipmi.go
new file mode 100644
index 0000000000..f3ecf7634c
--- /dev/null
+++ b/internal/component/prometheus/exporter/ipmi/ipmi.go
@@ -0,0 +1,68 @@
+package ipmi
+
+import (
+	"github.com/grafana/alloy/internal/component"
+	"github.com/grafana/alloy/internal/component/discovery"
+	"github.com/grafana/alloy/internal/component/prometheus/exporter"
+	"github.com/grafana/alloy/internal/featuregate"
+	"github.com/grafana/alloy/internal/static/integrations"
+)
+
+func init() {
+	component.Register(component.Registration{
+		Name:      "prometheus.exporter.ipmi",
+		Stability: featuregate.StabilityGenerallyAvailable,
+		Args:      Arguments{},
+		Exports:   exporter.Exports{},
+
+		Build: exporter.NewWithTargetBuilder(createExporter, "ipmi", buildIPMITargets),
+	})
+}
+
+func createExporter(opts component.Options, args component.Arguments) (integrations.Integration, string, error) {
+	a := args.(Arguments)
+	defaultInstanceKey := opts.ID // if cannot resolve instance key, use the component ID
+	return integrations.NewIntegrationWithInstanceKey(opts.Logger, a.Convert(), defaultInstanceKey)
+}
+
+// buildIPMITargets creates the exporter's discovery targets based on the defined IPMI targets.
+func buildIPMITargets(baseTarget discovery.Target, args component.Arguments) []discovery.Target {
+	var targets []discovery.Target
+
+	ipmiArgs := args.(Arguments)
+
+	// Handle local IPMI target if enabled
+	if ipmiArgs.Local.Enabled {
+		target := make(map[string]string, baseTarget.Len()+2)
+		baseTarget.ForEachLabel(func(key string, value string) bool {
+			target[key] = value
+			return true
+		})
+
+		target["job"] = target["job"] + "/local"
+		if ipmiArgs.Local.Module != "" {
+			target["__param_module"] = ipmiArgs.Local.Module
+		}
+
+		targets = append(targets, discovery.NewTargetFromMap(target))
+	}
+
+	// Handle remote IPMI targets
+	for _, tgt := range ipmiArgs.Targets {
+		target := make(map[string]string, baseTarget.Len()+6)
+		baseTarget.ForEachLabel(func(key string, value string) bool {
+			target[key] = value
+			return true
+		})
+
+		target["job"] = target["job"] + "/" + tgt.Name
+		target["__param_target"] = tgt.Target
+		if tgt.Module != "" {
+			target["__param_module"] = tgt.Module
+		}
+
+		targets = append(targets, discovery.NewTargetFromMap(target))
+	}
+
+	return targets
+}
diff --git a/internal/static/integrations/install/install.go b/internal/static/integrations/install/install.go
index 46b021703d..d1e72d0faf 100644
--- a/internal/static/integrations/install/install.go
+++ b/internal/static/integrations/install/install.go
@@ -18,6 +18,7 @@ import (
 	_ "github.com/grafana/alloy/internal/static/integrations/elasticsearch_exporter" // register elasticsearch_exporter
 	_ "github.com/grafana/alloy/internal/static/integrations/gcp_exporter"           // register gcp_exporter
 	_ "github.com/grafana/alloy/internal/static/integrations/github_exporter"        // register github_exporter
+	_ "github.com/grafana/alloy/internal/static/integrations/ipmi_exporter"          // register ipmi_exporter
 	_ "github.com/grafana/alloy/internal/static/integrations/kafka_exporter"         // register kafka_exporter
 	_ "github.com/grafana/alloy/internal/static/integrations/memcached_exporter"     // register memcached_exporter
 	_ "github.com/grafana/alloy/internal/static/integrations/mongodb_exporter"       // register mongodb_exporter
diff --git a/internal/static/integrations/ipmi_exporter/ipmi_exporter.go b/internal/static/integrations/ipmi_exporter/ipmi_exporter.go
new file mode 100644
index 0000000000..b3a92148d9
--- /dev/null
+++ b/internal/static/integrations/ipmi_exporter/ipmi_exporter.go
@@ -0,0 +1,538 @@
+// The IPMI exporter integration collects hardware metrics from IPMI-enabled devices.
+// It supports both local IPMI collection (from the machine running Alloy) and remote
+// IPMI collection from network-accessible devices.
+package ipmi_exporter
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"net/url"
+	"strings"
+	"time"
+
+	"github.com/bougou/go-ipmi"
+	"github.com/go-kit/log"
+	"github.com/go-kit/log/level"
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/prometheus/client_golang/prometheus/promhttp"
+	config_util "github.com/prometheus/common/config"
+
+	"github.com/grafana/alloy/internal/static/integrations"
+	config_integrations "github.com/grafana/alloy/internal/static/integrations/config"
+	integrations_v2 "github.com/grafana/alloy/internal/static/integrations/v2"
+	"github.com/grafana/alloy/internal/static/integrations/v2/metricsutils"
+	"github.com/grafana/alloy/internal/util"
+)
+
+// DefaultConfig holds the default settings for the ipmi_exporter integration.
+var DefaultConfig = Config{
+	Timeout: 30000, // 30 seconds in milliseconds (IPMI sensor collection can be slow)
+}
+
+// IPMITarget defines a target device to be monitored.
+type IPMITarget struct {
+	Name   string `yaml:"name"`
+	Target string `yaml:"target"`
+	Module string `yaml:"module,omitempty"`
+
+	// Authentication for remote IPMI (optional, can be defined in module config instead)
+	User      string             `yaml:"user,omitempty"`
+	Password  config_util.Secret `yaml:"password,omitempty"`
+	Driver    string             `yaml:"driver,omitempty"`    // LAN_2_0 or LAN
+	Privilege string             `yaml:"privilege,omitempty"` // user or admin
+}
+
+// LocalConfig controls local IPMI collection.
+type LocalConfig struct {
+	// Enabled controls whether local IPMI collection is enabled.
+	Enabled bool `yaml:"enabled,omitempty"`
+
+	// Module specifies which collector module to use for local collection.
+	Module string `yaml:"module,omitempty"`
+}
+
+// Config controls the ipmi_exporter integration.
+type Config struct {
+	// Local configures monitoring of the local machine's IPMI interface.
+	Local LocalConfig `yaml:"local,omitempty"`
+
+	// Targets to monitor via remote IPMI.
+	Targets []IPMITarget `yaml:"targets,omitempty"`
+
+	// Timeout for IPMI requests in milliseconds.
+	Timeout int64 `yaml:"timeout,omitempty"`
+
+	// ConfigFile points to an external ipmi_exporter configuration file.
+	// This file configures collectors, modules, and command overrides.
+	// See https://github.com/prometheus-community/ipmi_exporter for examples.
+	ConfigFile string `yaml:"config_file,omitempty"`
+
+	// IPMIConfig is the inline ipmi_exporter configuration.
+	// Mutually exclusive with ConfigFile.
+	IPMIConfig util.RawYAML `yaml:"ipmi_config,omitempty"`
+}
+
+// UnmarshalYAML implements yaml.Unmarshaler for Config.
+func (c *Config) UnmarshalYAML(unmarshal func(interface{}) error) error {
+	*c = DefaultConfig
+
+	type plain Config
+	return unmarshal((*plain)(c))
+}
+
+// Name returns the name of the integration.
+func (c *Config) Name() string {
+	return "ipmi_exporter"
+}
+
+// InstanceKey returns the hostname of the first target or default.
+func (c *Config) InstanceKey(defaultKey string) (string, error) {
+	if c.Local.Enabled {
+		return "localhost", nil
+	}
+	if len(c.Targets) == 1 {
+		return c.Targets[0].Target, nil
+	}
+	return defaultKey, nil
+}
+
+// NewIntegration creates a new ipmi_exporter integration.
+func (c *Config) NewIntegration(l log.Logger) (integrations.Integration, error) {
+	return New(l, c)
+}
+
+func init() {
+	integrations.RegisterIntegration(&Config{})
+	integrations_v2.RegisterLegacy(&Config{}, integrations_v2.TypeMultiplex, metricsutils.NewNamedShim("ipmi"))
+}
+
+// New creates a new ipmi_exporter integration.
+func New(log log.Logger, c *Config) (integrations.Integration, error) {
+	if !c.Local.Enabled && len(c.Targets) == 0 {
+		return nil, fmt.Errorf("either local IPMI collection must be enabled or at least one remote target must be configured")
+	}
+
+	// Validate remote targets
+	for _, target := range c.Targets {
+		if target.Name == "" || target.Target == "" {
+			return nil, fmt.Errorf("IPMI target must have both name and target fields set")
+		}
+	}
+
+	return &Integration{
+		cfg: c,
+		log: log,
+	}, nil
+}
+
+// Integration is the ipmi_exporter integration. It scrapes metrics from IPMI devices.
+type Integration struct {
+	cfg *Config
+	log log.Logger
+}
+
+// MetricsHandler implements Integration.
+func (i *Integration) MetricsHandler() (http.Handler, error) {
+	// Create a prometheus registry for IPMI metrics
+	registry := prometheus.NewRegistry()
+
+	// Register the IPMI collector for hardware monitoring
+	// Uses github.com/bougou/go-ipmi library for native Go IPMI collection
+	collector := newIPMICollector(i.cfg, i.log)
+	registry.MustRegister(collector)
+
+	return promhttp.HandlerFor(registry, promhttp.HandlerOpts{}), nil
+}
+
+// Run satisfies Integration.Run.
+func (i *Integration) Run(ctx context.Context) error {
+	// Wait for context cancellation
+	<-ctx.Done()
+	return ctx.Err()
+}
+
+// ScrapeConfigs satisfies Integration.ScrapeConfigs.
+func (i *Integration) ScrapeConfigs() []config_integrations.ScrapeConfig {
+	var res []config_integrations.ScrapeConfig
+
+	// Add local IPMI scrape config if enabled
+	if i.cfg.Local.Enabled {
+		scrapeConfig := config_integrations.ScrapeConfig{
+			JobName:     i.cfg.Name() + "/local",
+			MetricsPath: "/metrics",
+		}
+
+		// Add module parameter if specified
+		if i.cfg.Local.Module != "" {
+			queryParams := url.Values{}
+			queryParams.Add("module", i.cfg.Local.Module)
+			scrapeConfig.QueryParams = queryParams
+		}
+
+		res = append(res, scrapeConfig)
+	}
+
+	// Add remote target scrape configs
+	for _, target := range i.cfg.Targets {
+		queryParams := url.Values{}
+		queryParams.Add("target", target.Target)
+		if target.Module != "" {
+			queryParams.Add("module", target.Module)
+		}
+
+		res = append(res, config_integrations.ScrapeConfig{
+			JobName:     i.cfg.Name() + "/" + target.Name,
+			MetricsPath: "/metrics",
+			QueryParams: queryParams,
+		})
+	}
+
+	return res
+}
+
+// ipmiCollector implements prometheus.Collector for IPMI metrics
+type ipmiCollector struct {
+	cfg *Config
+	log log.Logger
+
+	// Metric descriptors
+	up                 *prometheus.Desc
+	temperatureCelsius *prometheus.Desc
+	fanSpeedRPM        *prometheus.Desc
+	voltageVolts       *prometheus.Desc
+	powerWatts         *prometheus.Desc
+	currentAmperes     *prometheus.Desc
+	sensorState        *prometheus.Desc
+	collectorInfo      *prometheus.Desc
+}
+
+func newIPMICollector(cfg *Config, logger log.Logger) *ipmiCollector {
+	return &ipmiCollector{
+		cfg: cfg,
+		log: logger,
+		up: prometheus.NewDesc(
+			"ipmi_up",
+			"IPMI device is reachable and responding (1=up, 0=down)",
+			[]string{"target"},
+			nil,
+		),
+		temperatureCelsius: prometheus.NewDesc(
+			"ipmi_temperature_celsius",
+			"Temperature sensor reading in degrees Celsius",
+			[]string{"target", "sensor", "id"},
+			nil,
+		),
+		fanSpeedRPM: prometheus.NewDesc(
+			"ipmi_fan_speed_rpm",
+			"Fan speed sensor reading in RPM",
+			[]string{"target", "sensor", "id"},
+			nil,
+		),
+		voltageVolts: prometheus.NewDesc(
+			"ipmi_voltage_volts",
+			"Voltage sensor reading in volts",
+			[]string{"target", "sensor", "id"},
+			nil,
+		),
+		powerWatts: prometheus.NewDesc(
+			"ipmi_power_watts",
+			"Power sensor reading in watts",
+			[]string{"target", "sensor", "id"},
+			nil,
+		),
+		currentAmperes: prometheus.NewDesc(
+			"ipmi_current_amperes",
+			"Current sensor reading in amperes",
+			[]string{"target", "sensor", "id"},
+			nil,
+		),
+		sensorState: prometheus.NewDesc(
+			"ipmi_sensor_state",
+			"Sensor state (0=nominal, 1=warning, 2=critical, 3=not available)",
+			[]string{"target", "sensor", "id"},
+			nil,
+		),
+		collectorInfo: prometheus.NewDesc(
+			"ipmi_collector_info",
+			"Information about the IPMI collector configuration",
+			[]string{"version", "mode"},
+			nil,
+		),
+	}
+}
+
+// Describe implements prometheus.Collector
+func (c *ipmiCollector) Describe(ch chan<- *prometheus.Desc) {
+	ch <- c.up
+	ch <- c.temperatureCelsius
+	ch <- c.fanSpeedRPM
+	ch <- c.voltageVolts
+	ch <- c.powerWatts
+	ch <- c.currentAmperes
+	ch <- c.sensorState
+	ch <- c.collectorInfo
+}
+
+// Collect implements prometheus.Collector
+func (c *ipmiCollector) Collect(ch chan<- prometheus.Metric) {
+	// Send collector info
+	mode := "remote"
+	if c.cfg.Local.Enabled {
+		mode = "local"
+	}
+	ch <- prometheus.MustNewConstMetric(
+		c.collectorInfo,
+		prometheus.GaugeValue,
+		1,
+		"1.0.0", // version
+		mode,
+	)
+
+	// Collect from local IPMI if enabled
+	if c.cfg.Local.Enabled {
+		c.collectLocal(ch)
+	}
+
+	// Collect from remote targets
+	for _, target := range c.cfg.Targets {
+		c.collectRemote(ch, target)
+	}
+}
+
+func (c *ipmiCollector) collectLocal(ch chan<- prometheus.Metric) {
+	ctx := context.Background()
+
+	// Create local IPMI client (uses OpenIPMI driver for local access)
+	client, err := ipmi.NewOpenClient()
+	if err != nil {
+		level.Error(c.log).Log("msg", "Failed to create local IPMI client", "error", err)
+		ch <- prometheus.MustNewConstMetric(
+			c.up,
+			prometheus.GaugeValue,
+			0,
+			"localhost",
+		)
+		return
+	}
+
+	// Attempt connection
+	if err := client.Connect(ctx); err != nil {
+		level.Error(c.log).Log("msg", "Failed to connect to local IPMI device", "error", err)
+		ch <- prometheus.MustNewConstMetric(
+			c.up,
+			prometheus.GaugeValue,
+			0,
+			"localhost",
+		)
+		return
+	}
+	defer client.Close(ctx)
+
+	// Connection successful
+	ch <- prometheus.MustNewConstMetric(
+		c.up,
+		prometheus.GaugeValue,
+		1,
+		"localhost",
+	)
+
+	// Get all sensors
+	sensors, err := client.GetSensors(ctx)
+	if err != nil {
+		level.Error(c.log).Log("msg", "Failed to get local sensors", "error", err)
+		return
+	}
+
+	// Iterate through all sensors
+	for _, sensor := range sensors {
+		// Convert sensor ID to string
+		sensorID := fmt.Sprintf("%d", sensor.Number)
+		sensorName := strings.TrimSpace(sensor.Name)
+
+		// Emit sensor state based on sensor status
+		stateValue := c.convertSensorStatus(sensor.Status())
+		ch <- prometheus.MustNewConstMetric(
+			c.sensorState,
+			prometheus.GaugeValue,
+			stateValue,
+			"localhost",
+			sensorName,
+			sensorID,
+		)
+
+		// Emit metric based on sensor type/unit
+		c.emitSensorMetric(ch, "localhost", sensorName, sensorID, sensor)
+	}
+}
+
+func (c *ipmiCollector) collectRemote(ch chan<- prometheus.Metric, target IPMITarget) {
+	// Create context with timeout from config
+	timeout := time.Duration(c.cfg.Timeout) * time.Millisecond
+	ctx, cancel := context.WithTimeout(context.Background(), timeout)
+	defer cancel()
+
+	level.Debug(c.log).Log("msg", "Starting IPMI collection", "target", target.Target, "timeout", timeout)
+
+	// Default IPMI port
+	port := 623
+
+	// Create IPMI client for remote access
+	client, err := ipmi.NewClient(target.Target, port, target.User, string(target.Password))
+	if err != nil {
+		level.Error(c.log).Log("msg", "Failed to create IPMI client", "target", target.Target, "error", err)
+		ch <- prometheus.MustNewConstMetric(
+			c.up,
+			prometheus.GaugeValue,
+			0,
+			target.Target,
+		)
+		return
+	}
+
+	// Set client timeout to 80% of total timeout to allow time for processing
+	client = client.WithTimeout(timeout * 4 / 5)
+
+	level.Debug(c.log).Log("msg", "Attempting IPMI connection", "target", target.Target, "driver", target.Driver)
+
+	// Attempt connection - use Connect20 for LAN_2_0 or Connect for auto-detect
+	var connectErr error
+	if target.Driver == "LAN_2_0" || target.Driver == "" {
+		connectErr = client.Connect20(ctx)
+	} else {
+		connectErr = client.Connect15(ctx)
+	}
+
+	if connectErr != nil {
+		level.Error(c.log).Log("msg", "Failed to connect to IPMI device", "target", target.Target, "driver", target.Driver, "error", connectErr)
+		ch <- prometheus.MustNewConstMetric(
+			c.up,
+			prometheus.GaugeValue,
+			0,
+			target.Target,
+		)
+		return
+	}
+	defer client.Close(ctx)
+
+	level.Debug(c.log).Log("msg", "IPMI connection successful", "target", target.Target)
+
+	// Connection successful
+	ch <- prometheus.MustNewConstMetric(
+		c.up,
+		prometheus.GaugeValue,
+		1,
+		target.Target,
+	)
+
+	// Get all sensors
+	level.Debug(c.log).Log("msg", "Fetching sensors from IPMI device", "target", target.Target)
+
+	sensors, err := client.GetSensors(ctx)
+	if err != nil {
+		// Log the error but still report ipmi_up=1 since we connected successfully
+		level.Warn(c.log).Log("msg", "Failed to retrieve sensors (connection succeeded but sensor reading failed)", "target", target.Target, "error", err)
+		// Don't return - we already set ipmi_up=1 which is accurate (connection worked)
+		return
+	}
+
+	level.Info(c.log).Log("msg", "Successfully retrieved sensors", "target", target.Target, "sensor_count", len(sensors))
+
+	// Iterate through all sensors
+	for _, sensor := range sensors {
+		// Convert sensor ID to string
+		sensorID := fmt.Sprintf("%d", sensor.Number)
+		sensorName := strings.TrimSpace(sensor.Name)
+
+		// Emit sensor state based on sensor status
+		stateValue := c.convertSensorStatus(sensor.Status())
+		ch <- prometheus.MustNewConstMetric(
+			c.sensorState,
+			prometheus.GaugeValue,
+			stateValue,
+			target.Target,
+			sensorName,
+			sensorID,
+		)
+
+		// Emit metric based on sensor type/unit
+		c.emitSensorMetric(ch, target.Target, sensorName, sensorID, sensor)
+	}
+}
+
+// convertSensorStatus converts IPMI sensor status string to numeric value
+func (c *ipmiCollector) convertSensorStatus(status string) float64 {
+	status = strings.ToLower(strings.TrimSpace(status))
+	switch status {
+	case "ok", "nominal":
+		return 0
+	case "warning", "warn", "nc":
+		return 1
+	case "critical", "crit", "cr":
+		return 2
+	case "n/a", "na", "unavailable":
+		return 3
+	default:
+		return 0
+	}
+}
+
+// emitSensorMetric emits the appropriate metric based on sensor unit
+func (c *ipmiCollector) emitSensorMetric(ch chan<- prometheus.Metric, target, sensorName, sensorID string, sensor *ipmi.Sensor) {
+	// Skip sensors without analog readings
+	if !sensor.HasAnalogReading {
+		return
+	}
+
+	// Use the already-converted value from the sensor
+	value := sensor.Value
+
+	// Determine metric type based on sensor base unit
+	switch sensor.SensorUnit.BaseUnit {
+	case ipmi.SensorUnitType_DegreesC:
+		ch <- prometheus.MustNewConstMetric(
+			c.temperatureCelsius,
+			prometheus.GaugeValue,
+			value,
+			target,
+			sensorName,
+			sensorID,
+		)
+	case ipmi.SensorUnitType_RPM:
+		ch <- prometheus.MustNewConstMetric(
+			c.fanSpeedRPM,
+			prometheus.GaugeValue,
+			value,
+			target,
+			sensorName,
+			sensorID,
+		)
+	case ipmi.SensorUnitType_Volts:
+		ch <- prometheus.MustNewConstMetric(
+			c.voltageVolts,
+			prometheus.GaugeValue,
+			value,
+			target,
+			sensorName,
+			sensorID,
+		)
+	case ipmi.SensorUnitType_Watts:
+		ch <- prometheus.MustNewConstMetric(
+			c.powerWatts,
+			prometheus.GaugeValue,
+			value,
+			target,
+			sensorName,
+			sensorID,
+		)
+	case ipmi.SensorUnitType_Amps:
+		ch <- prometheus.MustNewConstMetric(
+			c.currentAmperes,
+			prometheus.GaugeValue,
+			value,
+			target,
+			sensorName,
+			sensorID,
+		)
+	}
+}
diff --git a/internal/static/integrations/ipmi_exporter/ipmi_test.go b/internal/static/integrations/ipmi_exporter/ipmi_test.go
new file mode 100644
index 0000000000..c28c7337d8
--- /dev/null
+++ b/internal/static/integrations/ipmi_exporter/ipmi_test.go
@@ -0,0 +1,241 @@
+package ipmi_exporter
+
+import (
+	"testing"
+
+	"github.com/go-kit/log"
+	config_integrations "github.com/grafana/alloy/internal/static/integrations/config"
+	"github.com/stretchr/testify/require"
+)
+
+func TestConfig_Validate(t *testing.T) {
+	tests := []struct {
+		name    string
+		cfg     *Config
+		wantErr bool
+		errMsg  string
+	}{
+		{
+			name: "valid config with local IPMI",
+			cfg: &Config{
+				Local: LocalConfig{Enabled: true},
+			},
+			wantErr: false,
+		},
+		{
+			name: "valid config with local IPMI and module",
+			cfg: &Config{
+				Local: LocalConfig{Enabled: true, Module: "default"},
+			},
+			wantErr: false,
+		},
+		{
+			name: "valid config with single remote target",
+			cfg: &Config{
+				Targets: []IPMITarget{
+					{Name: "server1", Target: "192.168.1.100"},
+				},
+			},
+			wantErr: false,
+		},
+		{
+			name: "valid config with multiple remote targets",
+			cfg: &Config{
+				Targets: []IPMITarget{
+					{Name: "server1", Target: "192.168.1.100", Module: "default"},
+					{Name: "server2", Target: "192.168.1.101"},
+				},
+			},
+			wantErr: false,
+		},
+		{
+			name: "valid config with local and remote targets",
+			cfg: &Config{
+				Local: LocalConfig{Enabled: true},
+				Targets: []IPMITarget{
+					{Name: "server1", Target: "192.168.1.100"},
+				},
+			},
+			wantErr: false,
+		},
+		{
+			name:    "invalid config - no local or remote targets",
+			cfg:     &Config{},
+			wantErr: true,
+			errMsg:  "either local IPMI collection must be enabled or at least one remote target must be configured",
+		},
+		{
+			name: "invalid config - missing target name",
+			cfg: &Config{
+				Targets: []IPMITarget{
+					{Target: "192.168.1.100"},
+				},
+			},
+			wantErr: true,
+			errMsg:  "IPMI target must have both name and target fields set",
+		},
+		{
+			name: "invalid config - missing target address",
+			cfg: &Config{
+				Targets: []IPMITarget{
+					{Name: "server1"},
+				},
+			},
+			wantErr: true,
+			errMsg:  "IPMI target must have both name and target fields set",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			logger := log.NewNopLogger()
+			_, err := New(logger, tt.cfg)
+
+			if tt.wantErr {
+				require.Error(t, err)
+				if tt.errMsg != "" {
+					require.Contains(t, err.Error(), tt.errMsg)
+				}
+			} else {
+				require.NoError(t, err)
+			}
+		})
+	}
+}
+
+func TestConfig_Name(t *testing.T) {
+	cfg := &Config{}
+	require.Equal(t, "ipmi_exporter", cfg.Name())
+}
+
+func TestConfig_InstanceKey(t *testing.T) {
+	tests := []struct {
+		name       string
+		cfg        *Config
+		defaultKey string
+		want       string
+	}{
+		{
+			name: "local IPMI returns localhost",
+			cfg: &Config{
+				Local: LocalConfig{Enabled: true},
+			},
+			defaultKey: "default",
+			want:       "localhost",
+		},
+		{
+			name: "single remote target returns target address",
+			cfg: &Config{
+				Targets: []IPMITarget{
+					{Name: "server1", Target: "192.168.1.100"},
+				},
+			},
+			defaultKey: "default",
+			want:       "192.168.1.100",
+		},
+		{
+			name: "multiple remote targets return default key",
+			cfg: &Config{
+				Targets: []IPMITarget{
+					{Name: "server1", Target: "192.168.1.100"},
+					{Name: "server2", Target: "192.168.1.101"},
+				},
+			},
+			defaultKey: "default",
+			want:       "default",
+		},
+		{
+			name:       "no targets return default key",
+			cfg:        &Config{},
+			defaultKey: "default",
+			want:       "default",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := tt.cfg.InstanceKey(tt.defaultKey)
+			require.NoError(t, err)
+			require.Equal(t, tt.want, got)
+		})
+	}
+}
+
+func TestIntegration_ScrapeConfigs(t *testing.T) {
+	tests := []struct {
+		name      string
+		cfg       *Config
+		wantJobs  int
+		checkFunc func(t *testing.T, configs []config_integrations.ScrapeConfig)
+	}{
+		{
+			name: "local IPMI creates local job",
+			cfg: &Config{
+				Local: LocalConfig{Enabled: true},
+			},
+			wantJobs: 1,
+			checkFunc: func(t *testing.T, configs []config_integrations.ScrapeConfig) {
+				require.Equal(t, "ipmi_exporter/local", configs[0].JobName)
+				require.Equal(t, "/metrics", configs[0].MetricsPath)
+				require.Nil(t, configs[0].QueryParams)
+			},
+		},
+		{
+			name: "local IPMI with module",
+			cfg: &Config{
+				Local: LocalConfig{Enabled: true, Module: "default"},
+			},
+			wantJobs: 1,
+			checkFunc: func(t *testing.T, configs []config_integrations.ScrapeConfig) {
+				require.Equal(t, "ipmi_exporter/local", configs[0].JobName)
+				require.NotNil(t, configs[0].QueryParams)
+				require.Equal(t, "default", configs[0].QueryParams.Get("module"))
+			},
+		},
+		{
+			name: "single remote target",
+			cfg: &Config{
+				Targets: []IPMITarget{
+					{Name: "server1", Target: "192.168.1.100"},
+				},
+			},
+			wantJobs: 1,
+			checkFunc: func(t *testing.T, configs []config_integrations.ScrapeConfig) {
+				require.Equal(t, "ipmi_exporter/server1", configs[0].JobName)
+				require.Equal(t, "192.168.1.100", configs[0].QueryParams.Get("target"))
+			},
+		},
+		{
+			name: "local and remote targets",
+			cfg: &Config{
+				Local: LocalConfig{Enabled: true, Module: "local"},
+				Targets: []IPMITarget{
+					{Name: "server1", Target: "192.168.1.100", Module: "remote"},
+				},
+			},
+			wantJobs: 2,
+			checkFunc: func(t *testing.T, configs []config_integrations.ScrapeConfig) {
+				require.Equal(t, "ipmi_exporter/local", configs[0].JobName)
+				require.Equal(t, "local", configs[0].QueryParams.Get("module"))
+				require.Equal(t, "ipmi_exporter/server1", configs[1].JobName)
+				require.Equal(t, "192.168.1.100", configs[1].QueryParams.Get("target"))
+				require.Equal(t, "remote", configs[1].QueryParams.Get("module"))
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			logger := log.NewNopLogger()
+			integration, err := New(logger, tt.cfg)
+			require.NoError(t, err)
+
+			configs := integration.ScrapeConfigs()
+			require.Len(t, configs, tt.wantJobs)
+
+			if tt.checkFunc != nil {
+				tt.checkFunc(t, configs)
+			}
+		})
+	}
+}