diff --git a/CHANGELOG.md b/CHANGELOG.md
index e57d47702b..4de7c6974a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -12,6 +12,8 @@ Main (unreleased)
 
 ### Features
 
+- Add `otelcol.connector.count` component to count the number of spans, metrics, and logs passing through it. (@hhertout)
+
 - A new `mimir.alerts.kubernetes` component which discovers `AlertmanagerConfig` Kubernetes resources and loads them into a Mimir instance. (@ptodev)
 
 - Mark `stage.windowsevent` block in the `loki.process` component as GA. (@kgeckhart)
diff --git a/docs/sources/reference/components/otelcol/otelcol.connector.count.md b/docs/sources/reference/components/otelcol/otelcol.connector.count.md
new file mode 100644
index 0000000000..0bca097f55
--- /dev/null
+++ b/docs/sources/reference/components/otelcol/otelcol.connector.count.md
@@ -0,0 +1,370 @@
+---
+canonical: https://grafana.com/docs/alloy/latest/reference/components/otelcol/otelcol.connector.count/
+description: Learn about otelcol.connector.count
+labels:
+  stage: experimental
+  products:
+    - oss
+title: otelcol.connector.count
+---
+
+# `otelcol.connector.count`
+
+`otelcol.connector.count` accepts spans, span events, metrics, data points, and log records from other `otelcol` components and generates metrics that count the received telemetry data.
+
+{{< admonition type="note" >}}
+`otelcol.connector.count` is a wrapper over the upstream OpenTelemetry Collector Contrib `count` connector.
+Bug reports or feature requests are redirected to the upstream repository if necessary.
+{{< /admonition >}}
+
+You can specify multiple `otelcol.connector.count` components by giving them different labels.
+
+## Usage
+
+```alloy
+otelcol.connector.count "<LABEL>" {
+  output {
+    metrics = [...]
+  }
+}
+```
+
+## Arguments
+
+The `otelcol.connector.count` component doesn't support any arguments. You can configure this component with blocks.
+
+## Blocks
+
+You can use the following blocks with `otelcol.connector.count`:
+
+| Block                                     | Description                                                                | Required |
+| ----------------------------------------- | -------------------------------------------------------------------------- | -------- |
+| [`output`][output]                        | Configures where to send received telemetry data.                          | yes      |
+| [`datapoints`][datapoints]                | Configures custom metrics for counting data points.                        | no       |
+| `datapoints` > [`attributes`][attributes] | Groups data point counts by attribute values.                              | no       |
+| [`debug_metrics`][debug_metrics]          | Configures the metrics that this component generates to monitor its state. | no       |
+| [`logs`][logs]                            | Configures custom metrics for counting log records.                        | no       |
+| `logs` > [`attributes`][attributes]       | Groups log counts by attribute values.                                     | no       |
+| [`metrics`][metrics]                      | Configures custom metrics for counting metrics.                            | no       |
+| `metrics` > [`attributes`][attributes]    | Groups metric counts by attribute values.                                  | no       |
+| [`spanevents`][spanevents]                | Configures custom metrics for counting span events.                        | no       |
+| `spanevents` > [`attributes`][attributes] | Groups span event counts by attribute values.                              | no       |
+| [`spans`][spans]                          | Configures custom metrics for counting spans.                              | no       |
+| `spans` > [`attributes`][attributes]      | Groups span counts by attribute values.                                    | no       |
+
+The `>` symbol indicates deeper levels of nesting.
+For example, `spans` > `attributes` refers to an `attributes` block defined inside a `spans` block.
+
+[spans]: #spans
+[spanevents]: #spanevents
+[metrics]: #metrics
+[datapoints]: #datapoints
+[logs]: #logs
+[attributes]: #attributes
+[output]: #output
+[debug_metrics]: #debug_metrics
+
+### `spans`
+
+The `spans` block configures a custom metric for counting spans.
+
+You can specify multiple `spans` blocks to define different metrics.
+
+If you don't define any `spans` blocks, the connector emits a default metric named `trace.span.count`.
+
+| Name          | Type           | Description                           | Default                                    | Required |
+| ------------- | -------------- | ------------------------------------- | ------------------------------------------ | -------- |
+| `conditions`  | `list(string)` | OTTL expressions for filtering spans. | `[]`                                       | no       |
+| `description` | `string`       | Metric description.                   | `""`                                       | no       |
+| `name`        | `string`       | Metric name.                          | Uses default name based on telemetry type. | no       |
+
+The `conditions` argument accepts a list of [OTTL][] expressions that filter which spans to count.
+If any condition matches, the connector counts the span.
+If you don't specify conditions, the connector counts all spans.
+
+[OTTL]: https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/pkg/ottl
+
+### `spanevents`
+
+The `spanevents` block configures a custom metric for counting span events.
+
+You can specify multiple `spanevents` blocks to define different metrics.
+
+If you don't define any `spanevents` blocks, the connector emits a default metric named `trace.span.event.count`.
+
+This block shares the same configuration structure as [`spans`][spans].
+Refer to the [`spans`][spans] block documentation for the complete list of supported arguments and blocks.
+
+### `metrics`
+
+The `metrics` block configures a custom metric for counting metrics.
+
+You can specify multiple `metrics` blocks to define different metrics.
+
+If you don't define any `metrics` blocks, the connector emits a default metric named `metric.count`.
+
+This block shares the same configuration structure as [`spans`][spans].
+Refer to the [`spans`][spans] block documentation for the complete list of supported arguments and blocks.
+
+### `datapoints`
+
+The `datapoints` block configures a custom metric for counting data points.
+
+You can specify multiple `datapoints` blocks to define different metrics.
+
+If you don't define any `datapoints` blocks, the connector emits a default metric named `metric.datapoint.count`.
+
+This block shares the same configuration structure as [`spans`][spans].
+Refer to the [`spans`][spans] block documentation for the complete list of supported arguments and blocks.
+
+### `logs`
+
+The `logs` block configures a custom metric for counting log records.
+
+You can specify multiple `logs` blocks to define different metrics.
+
+If you don't define any `logs` blocks, the connector emits a default metric named `log.record.count`.
+
+This block shares the same configuration structure as [`spans`][spans].
+Refer to the [`spans`][spans] block documentation for the complete list of supported arguments and blocks.
+
+### `attributes`
+
+The `attributes` block specifies an attribute to use for grouping counted telemetry data.
+
+Each unique combination of attribute values generates a separate data point on the metric.
+
+You can specify multiple `attributes` blocks within `spans`, `spanevents`, `metrics`, `datapoints`, or `logs` blocks to group by multiple attributes.
+
+The following arguments are supported:
+
+| Name            | Type     | Description                                   | Default | Required |
+| --------------- | -------- | --------------------------------------------- | ------- | -------- |
+| `key`           | `string` | Attribute key name.                           |         | yes      |
+| `default_value` | `any`    | Default value if the attribute doesn't exist. |         | no       |
+
+Attribute precedence: span/log/metric attributes > scope attributes > resource attributes.
+
+### `output`
+
+{{< badge text="Required" >}}
+
+{{< docs/shared lookup="reference/components/output-block.md" source="alloy" version="<ALLOY_VERSION>" >}}
+
+### `debug_metrics`
+
+{{< docs/shared lookup="reference/components/otelcol-debug-metrics-block.md" source="alloy" version="<ALLOY_VERSION>" >}}
+
+## Exported fields
+
+The following fields are exported and can be referenced by other components:
+
+| Name    | Type               | Description                                                      |
+| ------- | ------------------ | ---------------------------------------------------------------- |
+| `input` | `otelcol.Consumer` | A value that other components can use to send telemetry data to. |
+
+`input` accepts `otelcol.Consumer` data for traces, metrics, and logs.
+
+he component counts all telemetry received through `input` according to the configured blocks and emits metrics to the components specified in `output`.
+
+## Component health
+
+`otelcol.connector.count` is only reported as unhealthy if given an invalid configuration.
+
+## Debug information
+
+`otelcol.connector.count` doesn't expose any component-specific debug information.
+
+## Examples
+
+### Default configuration
+
+Use the count connector with minimal configuration to count all telemetry data using default metric names.
+
+```alloy
+otelcol.connector.count "default" {
+  output {
+    metrics = [otelcol.exporter.otlp.default.input]
+  }
+}
+```
+
+This configuration generates the following default metrics:
+
+- `trace.span.count` - Count of all spans
+- `trace.span.event.count` - Count of all span events
+- `metric.count` - Count of all metrics
+- `metric.datapoint.count` - Count of all data points
+- `log.record.count` - Count of all log records
+
+### Custom metrics with conditions and attributes
+
+Create custom count metrics with filtering conditions and group counts by specific attributes.
+
+```alloy
+otelcol.connector.count "default" {
+  // Count only HTTP GET spans
+  spans {
+    name        = "http_get_requests"
+    description = "Number of HTTP GET requests"
+    conditions  = [
+      "attributes[\"http.method\"] == \"GET\"",
+    ]
+  }
+
+  // Count spans grouped by service and environment
+  spans {
+    name        = "spans_by_service"
+    description = "Spans per service and environment"
+    attributes {
+      key           = "service.name"
+      default_value = "unknown"
+    }
+    attributes {
+      key           = "env"
+      default_value = "production"
+    }
+  }
+
+  // Count error and fatal logs only
+  logs {
+    name        = "error_logs"
+    description = "Error and fatal log records"
+    conditions  = [
+      "severity_number >= 17",
+    ]
+  }
+
+  // Count logs by environment
+  logs {
+    name        = "logs_by_env"
+    description = "Log records per environment"
+    attributes {
+      key = "env"
+    }
+  }
+
+  output {
+    metrics = [otelcol.exporter.otlp.default.input]
+  }
+}
+```
+
+### Complete pipeline with Prometheus export
+
+Count spans, logs, and metrics, then export to Prometheus using the delta to cumulative processor.
+
+```alloy
+otelcol.receiver.otlp "default" {
+  grpc {
+    endpoint = "127.0.0.1:4317"
+  }
+
+  http {
+    endpoint = "127.0.0.1:4318"
+  }
+
+  output {
+    traces  = [otelcol.connector.count.default.input]
+    metrics = [otelcol.connector.count.default.input]
+    logs    = [otelcol.connector.count.default.input]
+  }
+}
+
+otelcol.connector.count "default" {
+  spans {
+    name        = "traces_total"
+    description = "Total number of spans received"
+  }
+
+  spans {
+    name        = "http_get_spans"
+    description = "HTTP GET requests"
+    conditions  = [
+      "attributes[\"http.method\"] == \"GET\"",
+    ]
+  }
+
+  spans {
+    name        = "spans_by_service"
+    description = "Spans grouped by service"
+    attributes {
+      key           = "service.name"
+      default_value = "unknown"
+    }
+  }
+
+  logs {
+    name        = "logs_total"
+    description = "Total number of logs received"
+  }
+
+  logs {
+    name        = "error_logs"
+    description = "Error level logs"
+    conditions  = [
+      "severity_number >= 17",
+    ]
+  }
+
+  metrics {
+    name        = "metrics_total"
+    description = "Total number of metrics received"
+  }
+
+  output {
+    metrics = [otelcol.processor.deltatocumulative.default.input]
+  }
+}
+
+// Convert delta metrics to cumulative for Prometheus compatibility
+otelcol.processor.deltatocumulative "default" {
+  output {
+    metrics = [otelcol.exporter.prometheus.default.input]
+  }
+}
+
+otelcol.exporter.prometheus "default" {
+  forward_to                       = [prometheus.remote_write.default.receiver]
+  add_metric_suffixes              = false
+  resource_to_telemetry_conversion = true
+}
+
+prometheus.remote_write "default" {
+  endpoint {
+    url = "http://localhost:9090/api/v1/write"
+  }
+}
+```
+
+## Technical details
+
+`otelcol.connector.count` uses the count connector from OpenTelemetry Collector Contrib.
+
+All generated metrics use the Sum data type with Delta aggregation temporality.
+
+{{< admonition type="note" >}}
+Prometheus doesn't natively support delta metrics.
+Use [`otelcol.processor.deltatocumulative`][otelcol.processor.deltatocumulative] to convert delta metrics to cumulative before sending to Prometheus.
+
+[otelcol.processor.deltatocumulative]: ../otelcol.processor.deltatocumulative/
+{{< /admonition >}}
+
+<!-- START GENERATED COMPATIBLE COMPONENTS -->
+
+## Compatible components
+
+`otelcol.connector.count` can accept arguments from the following components:
+
+- Components that export [OpenTelemetry `otelcol.Consumer`](../../../compatibility/#opentelemetry-otelcolconsumer-exporters)
+
+`otelcol.connector.count` has exports that can be consumed by the following components:
+
+- Components that consume [OpenTelemetry `otelcol.Consumer`](../../../compatibility/#opentelemetry-otelcolconsumer-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 93cd05a9da..070a73bfd7 100644
--- a/go.mod
+++ b/go.mod
@@ -116,6 +116,7 @@ require (
 	github.com/oklog/run v1.2.0
 	github.com/olekukonko/tablewriter v0.0.5
 	github.com/oliver006/redis_exporter v1.74.0
+  github.com/open-telemetry/opentelemetry-collector-contrib/connector/countconnector v0.139.0
 	github.com/open-telemetry/opentelemetry-collector-contrib/connector/servicegraphconnector v0.139.0
 	github.com/open-telemetry/opentelemetry-collector-contrib/connector/spanmetricsconnector v0.139.0
 	github.com/open-telemetry/opentelemetry-collector-contrib/exporter/awss3exporter v0.139.0
diff --git a/go.sum b/go.sum
index 47ff4c03be..2db4b92ca6 100644
--- a/go.sum
+++ b/go.sum
@@ -1755,6 +1755,8 @@ github.com/onsi/ginkgo/v2 v2.23.4 h1:ktYTpKJAVZnDT4VjxSbiBenUjmlL/5QkBEocaWXiQus
 github.com/onsi/ginkgo/v2 v2.23.4/go.mod h1:Bt66ApGPBFzHyR+JO10Zbt0Gsp4uWxu5mIOTusL46e8=
 github.com/onsi/gomega v1.37.0 h1:CdEG8g0S133B4OswTDC/5XPSzE1OeP29QOioj2PID2Y=
 github.com/onsi/gomega v1.37.0/go.mod h1:8D9+Txp43QWKhM24yyOBEdpkzN8FvJyAwecBgsU4KU0=
+github.com/open-telemetry/opentelemetry-collector-contrib/connector/countconnector v0.139.0 h1:L/mt81EynyqP8+Eo1RScotNMKodU8tzu5kdDVZsxzos=
+github.com/open-telemetry/opentelemetry-collector-contrib/connector/countconnector v0.139.0/go.mod h1:aamgZ/EgklfjbFzEpZHJFw6558jhx7iVrH/BF4aIkDM=
 github.com/open-telemetry/opentelemetry-collector-contrib/connector/servicegraphconnector v0.139.0 h1:wsylHna5nuu6Jl+ow9uv3WJ0qKGJxg2aRORFUDa8SAs=
 github.com/open-telemetry/opentelemetry-collector-contrib/connector/servicegraphconnector v0.139.0/go.mod h1:LIR7KA0MIoHFQN/mO3zLEeK7piZL3cR6Ig10GfpS5UU=
 github.com/open-telemetry/opentelemetry-collector-contrib/connector/spanmetricsconnector v0.139.0 h1:USQU4VEL4Vi1rDm1am6LFjIvRGSOWhb+huw1OLIo3Eo=
diff --git a/internal/component/all/all.go b/internal/component/all/all.go
index 1b71ab1e62..efa11f441e 100644
--- a/internal/component/all/all.go
+++ b/internal/component/all/all.go
@@ -68,6 +68,7 @@ import (
 	_ "github.com/grafana/alloy/internal/component/otelcol/auth/headers"                     // Import otelcol.auth.headers
 	_ "github.com/grafana/alloy/internal/component/otelcol/auth/oauth2"                      // Import otelcol.auth.oauth2
 	_ "github.com/grafana/alloy/internal/component/otelcol/auth/sigv4"                       // Import otelcol.auth.sigv4
+	_ "github.com/grafana/alloy/internal/component/otelcol/connector/count"                  // Import otelcol.connector.count
 	_ "github.com/grafana/alloy/internal/component/otelcol/connector/host_info"              // Import otelcol.connector.host_info
 	_ "github.com/grafana/alloy/internal/component/otelcol/connector/servicegraph"           // Import otelcol.connector.servicegraph
 	_ "github.com/grafana/alloy/internal/component/otelcol/connector/spanlogs"               // Import otelcol.connector.spanlogs
diff --git a/internal/component/otelcol/connector/connector.go b/internal/component/otelcol/connector/connector.go
index c2e31665a4..bc332be930 100644
--- a/internal/component/otelcol/connector/connector.go
+++ b/internal/component/otelcol/connector/connector.go
@@ -29,7 +29,7 @@ import (
 )
 
 const (
-	ConnectorTracesToTraces = iota
+	ConnectorTracesToTraces = iota + 1
 	ConnectorTracesToMetrics
 	ConnectorTracesToLogs
 	ConnectorMetricsToTraces
@@ -195,20 +195,32 @@ func (p *Connector) Update(args component.Arguments) error {
 	var metricsConnector otelconnector.Metrics
 	var logsConnector otelconnector.Logs
 
-	switch p.args.ConnectorType() {
-	case ConnectorTracesToMetrics:
-		if len(next.Traces) > 0 || len(next.Logs) > 0 {
-			return errors.New("this connector can only output metrics")
-		}
+	connectorType := p.args.ConnectorType()
+
+	// Validate that the connector supports the requested output types
+	if !outputsToMetrics(connectorType) && len(next.Metrics) > 0 {
+		return errors.New("this connector cannot output metrics")
+	}
+
+	if !outputsToLogs(connectorType) && len(next.Logs) > 0 {
+		return errors.New("logs output is not supported yet")
+	}
 
-		if len(next.Metrics) > 0 {
-			fanout := fanoutconsumer.Metrics(next.Metrics)
-			metricsInterceptor := interceptconsumer.Metrics(fanout,
-				func(ctx context.Context, md pmetric.Metrics) error {
-					livedebuggingpublisher.PublishMetricsIfActive(p.debugDataPublisher, p.opts.ID, md, otelcol.GetComponentMetadata(next.Metrics))
-					return fanout.ConsumeMetrics(ctx, md)
-				},
-			)
+	if !outputsToTraces(connectorType) && len(next.Traces) > 0 {
+		return errors.New("traces output is not supported yet")
+	}
+
+	if len(next.Metrics) > 0 {
+		fanout := fanoutconsumer.Metrics(next.Metrics)
+		metricsInterceptor := interceptconsumer.Metrics(fanout,
+			func(ctx context.Context, md pmetric.Metrics) error {
+				livedebuggingpublisher.PublishMetricsIfActive(p.debugDataPublisher, p.opts.ID, md, otelcol.GetComponentMetadata(next.Metrics))
+				return fanout.ConsumeMetrics(ctx, md)
+			},
+		)
+
+		// Create traces to metrics connector if supported
+		if (connectorType & ConnectorTracesToMetrics) != 0 {
 			tracesConnector, err = p.factory.CreateTracesToMetrics(p.ctx, settings, connectorConfig, metricsInterceptor)
 			if err != nil && !errors.Is(err, pipeline.ErrSignalNotSupported) {
 				return err
@@ -216,19 +228,19 @@ func (p *Connector) Update(args component.Arguments) error {
 				components = append(components, tracesConnector)
 			}
 		}
-	case ConnectorLogsToMetrics:
-		if len(next.Traces) > 0 || len(next.Logs) > 0 {
-			return errors.New("this connector can only output metrics")
+
+		// Create metrics to metrics connector if supported
+		if (connectorType & ConnectorMetricsToMetrics) != 0 {
+			metricsConnector, err = p.factory.CreateMetricsToMetrics(p.ctx, settings, connectorConfig, metricsInterceptor)
+			if err != nil && !errors.Is(err, pipeline.ErrSignalNotSupported) {
+				return err
+			} else if metricsConnector != nil {
+				components = append(components, metricsConnector)
+			}
 		}
 
-		if len(next.Metrics) > 0 {
-			fanout := fanoutconsumer.Metrics(next.Metrics)
-			metricsInterceptor := interceptconsumer.Metrics(fanout,
-				func(ctx context.Context, md pmetric.Metrics) error {
-					livedebuggingpublisher.PublishMetricsIfActive(p.debugDataPublisher, p.opts.ID, md, otelcol.GetComponentMetadata(next.Metrics))
-					return fanout.ConsumeMetrics(ctx, md)
-				},
-			)
+		// Create logs to metrics connector if supported
+		if (connectorType & ConnectorLogsToMetrics) != 0 {
 			logsConnector, err = p.factory.CreateLogsToMetrics(p.ctx, settings, connectorConfig, metricsInterceptor)
 			if err != nil && !errors.Is(err, pipeline.ErrSignalNotSupported) {
 				return err
@@ -236,8 +248,10 @@ func (p *Connector) Update(args component.Arguments) error {
 				components = append(components, logsConnector)
 			}
 		}
-	default:
-		return errors.New("unsupported connector type")
+	}
+
+	if len(components) == 0 {
+		return errors.New("no connectors were created")
 	}
 
 	updateConsumersFunc := func() {
@@ -255,3 +269,27 @@ func (p *Connector) CurrentHealth() component.Health {
 }
 
 func (p *Connector) LiveDebugging() {}
+
+// outputsToMetrics checks if the connector can output metrics by testing if any of the
+// *ToMetrics flags are set in the connectorType.
+func outputsToMetrics(connectorType int) bool {
+	return (connectorType&ConnectorTracesToMetrics) != 0 ||
+		(connectorType&ConnectorMetricsToMetrics) != 0 ||
+		(connectorType&ConnectorLogsToMetrics) != 0
+}
+
+// outputsToLogs checks if the connector can output logs by testing if any of the
+// *ToLogs flags are set in the connectorType.
+func outputsToLogs(connectorType int) bool {
+	return (connectorType&ConnectorTracesToLogs) != 0 ||
+		(connectorType&ConnectorMetricsToLogs) != 0 ||
+		(connectorType&ConnectorLogsToLogs) != 0
+}
+
+// outputsToTraces checks if the connector can output traces by testing if any of the
+// *ToTraces flags are set in the connectorType.
+func outputsToTraces(connectorType int) bool {
+	return (connectorType&ConnectorTracesToTraces) != 0 ||
+		(connectorType&ConnectorMetricsToTraces) != 0 ||
+		(connectorType&ConnectorLogsToTraces) != 0
+}
diff --git a/internal/component/otelcol/connector/count/count.go b/internal/component/otelcol/connector/count/count.go
new file mode 100644
index 0000000000..0ebad84c1a
--- /dev/null
+++ b/internal/component/otelcol/connector/count/count.go
@@ -0,0 +1,224 @@
+package count
+
+import (
+	"github.com/grafana/alloy/internal/component"
+	"github.com/grafana/alloy/internal/component/otelcol"
+	otelcolCfg "github.com/grafana/alloy/internal/component/otelcol/config"
+	"github.com/grafana/alloy/internal/component/otelcol/connector"
+	"github.com/grafana/alloy/internal/featuregate"
+	"github.com/open-telemetry/opentelemetry-collector-contrib/connector/countconnector"
+	otelcomponent "go.opentelemetry.io/collector/component"
+	"go.opentelemetry.io/collector/pipeline"
+)
+
+// Default metric names and descriptions follow OpenTelemetry Collector conventions.
+const (
+	defaultMetricNameSpans = "trace.span.count"
+	defaultMetricDescSpans = "The number of spans observed."
+
+	defaultMetricNameSpanEvents = "trace.span.event.count"
+	defaultMetricDescSpanEvents = "The number of span events observed."
+
+	defaultMetricNameMetrics = "metric.count"
+	defaultMetricDescMetrics = "The number of metrics observed."
+
+	defaultMetricNameDataPoints = "metric.datapoint.count"
+	defaultMetricDescDataPoints = "The number of data points observed."
+
+	defaultMetricNameLogs = "log.record.count"
+	defaultMetricDescLogs = "The number of log records observed."
+)
+
+const (
+	kindSpans      = "spans"
+	kindSpanEvents = "spanevents"
+	kindMetrics    = "metrics"
+	kindDataPoints = "datapoints"
+	kindLogs       = "logs"
+)
+
+func init() {
+	component.Register(component.Registration{
+		Name:      "otelcol.connector.count",
+		Stability: featuregate.StabilityGenerallyAvailable,
+		Args:      Arguments{},
+		Exports:   otelcol.ConsumerExports{},
+
+		Build: func(opts component.Options, args component.Arguments) (component.Component, error) {
+			f := countconnector.NewFactory()
+			return connector.New(opts, f, args.(Arguments))
+		},
+	})
+}
+
+// Arguments configures the otelcol.connector.count component.
+type Arguments struct {
+	// Config match the configuration structure of the otel count connector.
+	Spans      []MetricInfo `alloy:"spans,block,optional"`
+	SpanEvents []MetricInfo `alloy:"spanevents,block,optional"`
+	Metrics    []MetricInfo `alloy:"metrics,block,optional"`
+	DataPoints []MetricInfo `alloy:"datapoints,block,optional"`
+	Logs       []MetricInfo `alloy:"logs,block,optional"`
+
+	// Output configures where to send processed data. Required.
+	Output *otelcol.ConsumerArguments `alloy:"output,block"`
+
+	// DebugMetrics configures component internal metrics. Optional.
+	DebugMetrics otelcolCfg.DebugMetricsArguments `alloy:"debug_metrics,block,optional"`
+}
+
+type MetricInfo struct {
+	Name        string            `alloy:"name,attr,optional"`
+	Description string            `alloy:"description,attr,optional"`
+	Conditions  []string          `alloy:"conditions,attr,optional"`
+	Attributes  []AttributeConfig `alloy:"attributes,block,optional"`
+}
+
+type AttributeConfig struct {
+	Key          string `alloy:"key,attr"`
+	DefaultValue any    `alloy:"default_value,attr,optional"`
+}
+
+func (args *Arguments) SetToDefault() {
+	// Do not initialize slices here - let them be empty by default.
+	// Default metrics are created in Convert() if no custom metrics are defined.
+	args.DebugMetrics.SetToDefault()
+}
+
+func NewMetricInfo(kind string) MetricInfo {
+	var name, desc string
+
+	switch kind {
+	case kindSpans:
+		name = defaultMetricNameSpans
+		desc = defaultMetricDescSpans
+	case kindSpanEvents:
+		name = defaultMetricNameSpanEvents
+		desc = defaultMetricDescSpanEvents
+	case kindMetrics:
+		name = defaultMetricNameMetrics
+		desc = defaultMetricDescMetrics
+	case kindDataPoints:
+		name = defaultMetricNameDataPoints
+		desc = defaultMetricDescDataPoints
+	case kindLogs:
+		name = defaultMetricNameLogs
+		desc = defaultMetricDescLogs
+	}
+
+	return MetricInfo{
+		Name:        name,
+		Description: desc,
+	}
+}
+
+func (args *Arguments) Validate() error {
+	return nil
+}
+
+func (args Arguments) Convert() (otelcomponent.Config, error) {
+	// If no custom metrics are defined for a signal type, create default metrics
+	spans := make(map[string]countconnector.MetricInfo, max(len(args.Spans), 1))
+	if len(args.Spans) == 0 {
+		info := NewMetricInfo(kindSpans)
+		spans[info.Name] = info.Convert()
+	} else {
+		for _, info := range args.Spans {
+			spans[info.Name] = info.Convert()
+		}
+	}
+
+	spanEvents := make(map[string]countconnector.MetricInfo, max(len(args.SpanEvents), 1))
+	if len(args.SpanEvents) == 0 {
+		info := NewMetricInfo(kindSpanEvents)
+		spanEvents[info.Name] = info.Convert()
+	} else {
+		for _, info := range args.SpanEvents {
+			spanEvents[info.Name] = info.Convert()
+		}
+	}
+
+	metrics := make(map[string]countconnector.MetricInfo, max(len(args.Metrics), 1))
+	if len(args.Metrics) == 0 {
+		info := NewMetricInfo(kindMetrics)
+		metrics[info.Name] = info.Convert()
+	} else {
+		for _, info := range args.Metrics {
+			metrics[info.Name] = info.Convert()
+		}
+	}
+
+	dataPoints := make(map[string]countconnector.MetricInfo, max(len(args.DataPoints), 1))
+	if len(args.DataPoints) == 0 {
+		info := NewMetricInfo(kindDataPoints)
+		dataPoints[info.Name] = info.Convert()
+	} else {
+		for _, info := range args.DataPoints {
+			dataPoints[info.Name] = info.Convert()
+		}
+	}
+
+	logs := make(map[string]countconnector.MetricInfo, max(len(args.Logs), 1))
+	if len(args.Logs) == 0 {
+		info := NewMetricInfo(kindLogs)
+		logs[info.Name] = info.Convert()
+	} else {
+		for _, info := range args.Logs {
+			logs[info.Name] = info.Convert()
+		}
+	}
+
+	conf := &countconnector.Config{
+		Spans:      spans,
+		SpanEvents: spanEvents,
+		Metrics:    metrics,
+		DataPoints: dataPoints,
+		Logs:       logs,
+	}
+
+	return conf, nil
+}
+
+func (mi *MetricInfo) Convert() countconnector.MetricInfo {
+	a := make([]countconnector.AttributeConfig, len(mi.Attributes))
+	for i, attr := range mi.Attributes {
+		a[i] = attr.Convert()
+	}
+	return countconnector.MetricInfo{
+		Description: mi.Description,
+		Conditions:  mi.Conditions,
+		Attributes:  a,
+	}
+}
+
+func (a *AttributeConfig) Convert() countconnector.AttributeConfig {
+	return countconnector.AttributeConfig{
+		Key:          a.Key,
+		DefaultValue: a.DefaultValue,
+	}
+}
+
+// Extensions implements connector.Arguments.
+func (args Arguments) Extensions() map[otelcomponent.ID]otelcomponent.Component {
+	return nil
+}
+
+// Exporters implements connector.Arguments.
+func (args Arguments) Exporters() map[pipeline.Signal]map[otelcomponent.ID]otelcomponent.Component {
+	return nil
+}
+
+// NextConsumers implements connector.Arguments.
+func (args Arguments) NextConsumers() *otelcol.ConsumerArguments {
+	return args.Output
+}
+
+// ConnectorType() int implements connector.Arguments.
+func (Arguments) ConnectorType() int {
+	return connector.ConnectorLogsToMetrics | connector.ConnectorTracesToMetrics | connector.ConnectorMetricsToMetrics
+}
+
+// DebugMetricsConfig implements connector.Arguments.
+func (args Arguments) DebugMetricsConfig() otelcolCfg.DebugMetricsArguments {
+	return args.DebugMetrics
+}
diff --git a/internal/component/otelcol/connector/count/count_test.go b/internal/component/otelcol/connector/count/count_test.go
new file mode 100644
index 0000000000..8898ad8d44
--- /dev/null
+++ b/internal/component/otelcol/connector/count/count_test.go
@@ -0,0 +1,268 @@
+package count_test
+
+import (
+	"testing"
+
+	"github.com/grafana/alloy/internal/component/otelcol/connector/count"
+	"github.com/grafana/alloy/syntax"
+	"github.com/open-telemetry/opentelemetry-collector-contrib/connector/countconnector"
+	"github.com/stretchr/testify/require"
+)
+
+func TestArguments_UnmarshalAlloy(t *testing.T) {
+	tests := []struct {
+		testName string
+		cfg      string
+		expected countconnector.Config
+	}{
+		{
+			testName: "Defaults",
+			cfg: `
+				output {}
+			`,
+			expected: countconnector.Config{
+				Spans: map[string]countconnector.MetricInfo{
+					"trace.span.count": {
+						Description: "The number of spans observed.",
+						Attributes:  []countconnector.AttributeConfig{},
+					},
+				},
+				SpanEvents: map[string]countconnector.MetricInfo{
+					"trace.span.event.count": {
+						Description: "The number of span events observed.",
+						Attributes:  []countconnector.AttributeConfig{},
+					},
+				},
+				Metrics: map[string]countconnector.MetricInfo{
+					"metric.count": {
+						Description: "The number of metrics observed.",
+						Attributes:  []countconnector.AttributeConfig{},
+					},
+				},
+				DataPoints: map[string]countconnector.MetricInfo{
+					"metric.datapoint.count": {
+						Description: "The number of data points observed.",
+						Attributes:  []countconnector.AttributeConfig{},
+					},
+				},
+				Logs: map[string]countconnector.MetricInfo{
+					"log.record.count": {
+						Description: "The number of log records observed.",
+						Attributes:  []countconnector.AttributeConfig{},
+					},
+				},
+			},
+		},
+		{
+			testName: "CustomSpansCount",
+			cfg: `
+				spans {
+					name = "my_span_count"
+					description = "My custom span count"
+				}
+
+				output {}
+			`,
+			expected: countconnector.Config{
+				Spans: map[string]countconnector.MetricInfo{
+					"my_span_count": {
+						Description: "My custom span count",
+						Attributes:  []countconnector.AttributeConfig{},
+					},
+				},
+				SpanEvents: map[string]countconnector.MetricInfo{
+					"trace.span.event.count": {
+						Description: "The number of span events observed.",
+						Attributes:  []countconnector.AttributeConfig{},
+					},
+				},
+				Metrics: map[string]countconnector.MetricInfo{
+					"metric.count": {
+						Description: "The number of metrics observed.",
+						Attributes:  []countconnector.AttributeConfig{},
+					},
+				},
+				DataPoints: map[string]countconnector.MetricInfo{
+					"metric.datapoint.count": {
+						Description: "The number of data points observed.",
+						Attributes:  []countconnector.AttributeConfig{},
+					},
+				},
+				Logs: map[string]countconnector.MetricInfo{
+					"log.record.count": {
+						Description: "The number of log records observed.",
+						Attributes:  []countconnector.AttributeConfig{},
+					},
+				},
+			},
+		},
+		{
+			testName: "WithConditions",
+			cfg: `
+				logs {
+					name = "error_log_count"
+					description = "Count of error logs"
+					conditions = [
+						"severity_number >= SEVERITY_NUMBER_ERROR",
+					]
+				}
+
+				output {}
+			`,
+			expected: countconnector.Config{
+				Spans: map[string]countconnector.MetricInfo{
+					"trace.span.count": {
+						Description: "The number of spans observed.",
+						Attributes:  []countconnector.AttributeConfig{},
+					},
+				},
+				SpanEvents: map[string]countconnector.MetricInfo{
+					"trace.span.event.count": {
+						Description: "The number of span events observed.",
+						Attributes:  []countconnector.AttributeConfig{},
+					},
+				},
+				Metrics: map[string]countconnector.MetricInfo{
+					"metric.count": {
+						Description: "The number of metrics observed.",
+						Attributes:  []countconnector.AttributeConfig{},
+					},
+				},
+				DataPoints: map[string]countconnector.MetricInfo{
+					"metric.datapoint.count": {
+						Description: "The number of data points observed.",
+						Attributes:  []countconnector.AttributeConfig{},
+					},
+				},
+				Logs: map[string]countconnector.MetricInfo{
+					"error_log_count": {
+						Description: "Count of error logs",
+						Conditions: []string{
+							"severity_number >= SEVERITY_NUMBER_ERROR",
+						},
+						Attributes: []countconnector.AttributeConfig{},
+					},
+				},
+			},
+		},
+		{
+			testName: "WithAttributes",
+			cfg: `
+				datapoints {
+					name = "datapoint_by_service"
+					description = "Data points grouped by service"
+					attributes {
+						key = "service.name"
+					}
+				}
+
+				output {}
+			`,
+			expected: countconnector.Config{
+				Spans: map[string]countconnector.MetricInfo{
+					"trace.span.count": {
+						Description: "The number of spans observed.",
+						Attributes:  []countconnector.AttributeConfig{},
+					},
+				},
+				SpanEvents: map[string]countconnector.MetricInfo{
+					"trace.span.event.count": {
+						Description: "The number of span events observed.",
+						Attributes:  []countconnector.AttributeConfig{},
+					},
+				},
+				Metrics: map[string]countconnector.MetricInfo{
+					"metric.count": {
+						Description: "The number of metrics observed.",
+						Attributes:  []countconnector.AttributeConfig{},
+					},
+				},
+				DataPoints: map[string]countconnector.MetricInfo{
+					"datapoint_by_service": {
+						Description: "Data points grouped by service",
+						Attributes: []countconnector.AttributeConfig{
+							{
+								Key: "service.name",
+							},
+						},
+					},
+				},
+				Logs: map[string]countconnector.MetricInfo{
+					"log.record.count": {
+						Description: "The number of log records observed.",
+						Attributes:  []countconnector.AttributeConfig{},
+					},
+				},
+			},
+		},
+		{
+			testName: "WithAttributesAndDefaults",
+			cfg: `
+				spans {
+					name = "span_by_env"
+					description = "Spans grouped by environment"
+					attributes {
+						key           = "env"
+						default_value = "production"
+					}
+				}
+
+				output {}
+			`,
+			expected: countconnector.Config{
+				Spans: map[string]countconnector.MetricInfo{
+					"span_by_env": {
+						Description: "Spans grouped by environment",
+						Attributes: []countconnector.AttributeConfig{
+							{
+								Key:          "env",
+								DefaultValue: "production",
+							},
+						},
+					},
+				},
+				SpanEvents: map[string]countconnector.MetricInfo{
+					"trace.span.event.count": {
+						Description: "The number of span events observed.",
+						Attributes:  []countconnector.AttributeConfig{},
+					},
+				},
+				Metrics: map[string]countconnector.MetricInfo{
+					"metric.count": {
+						Description: "The number of metrics observed.",
+						Attributes:  []countconnector.AttributeConfig{},
+					},
+				},
+				DataPoints: map[string]countconnector.MetricInfo{
+					"metric.datapoint.count": {
+						Description: "The number of data points observed.",
+						Attributes:  []countconnector.AttributeConfig{},
+					},
+				},
+				Logs: map[string]countconnector.MetricInfo{
+					"log.record.count": {
+						Description: "The number of log records observed.",
+						Attributes:  []countconnector.AttributeConfig{},
+					},
+				},
+			},
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.testName, func(t *testing.T) {
+			var args count.Arguments
+			err := syntax.Unmarshal([]byte(tc.cfg), &args)
+			require.NoError(t, err)
+
+			err = args.Validate()
+			require.NoError(t, err)
+
+			actualConfig, err := args.Convert()
+			require.NoError(t, err)
+
+			actual := actualConfig.(*countconnector.Config)
+			require.Equal(t, tc.expected, *actual)
+		})
+	}
+}
diff --git a/internal/converter/internal/otelcolconvert/converter_countconnector.go b/internal/converter/internal/otelcolconvert/converter_countconnector.go
new file mode 100644
index 0000000000..0a297943bd
--- /dev/null
+++ b/internal/converter/internal/otelcolconvert/converter_countconnector.go
@@ -0,0 +1,141 @@
+package otelcolconvert
+
+import (
+	"fmt"
+	"sort"
+
+	"github.com/grafana/alloy/internal/component/otelcol"
+	"github.com/grafana/alloy/internal/component/otelcol/connector/count"
+	"github.com/grafana/alloy/internal/converter/diag"
+	"github.com/grafana/alloy/internal/converter/internal/common"
+	"github.com/open-telemetry/opentelemetry-collector-contrib/connector/countconnector"
+	"go.opentelemetry.io/collector/component"
+	"go.opentelemetry.io/collector/component/componentstatus"
+	"go.opentelemetry.io/collector/pipeline"
+)
+
+func init() {
+	converters = append(converters, countConnectorConverter{})
+}
+
+type countConnectorConverter struct{}
+
+func (countConnectorConverter) Factory() component.Factory {
+	return countconnector.NewFactory()
+}
+
+func (countConnectorConverter) InputComponentName() string {
+	return "otelcol.connector.count"
+}
+
+func (countConnectorConverter) ConvertAndAppend(state *State, id componentstatus.InstanceID, cfg component.Config) diag.Diagnostics {
+	var diags diag.Diagnostics
+
+	label := state.AlloyComponentLabel()
+
+	args := toCountConnector(state, id, cfg.(*countconnector.Config))
+	block := common.NewBlockWithOverride([]string{"otelcol", "connector", "count"}, label, args)
+
+	diags.Add(
+		diag.SeverityLevelInfo,
+		fmt.Sprintf("Converted %s into %s", StringifyInstanceID(id), StringifyBlock(block)),
+	)
+
+	state.Body().AppendBlock(block)
+	return diags
+}
+
+func toCountConnector(state *State, id componentstatus.InstanceID, cfg *countconnector.Config) *count.Arguments {
+	if cfg == nil {
+		return nil
+	}
+	var (
+		nextMetrics = state.Next(id, pipeline.SignalMetrics)
+	)
+
+	// Convert spans (sorted by name for deterministic output)
+	var spans []count.MetricInfo
+	spanNames := make([]string, 0, len(cfg.Spans))
+	for name := range cfg.Spans {
+		spanNames = append(spanNames, name)
+	}
+	sort.Strings(spanNames)
+	for _, name := range spanNames {
+		spans = append(spans, toCountMetricInfo(name, cfg.Spans[name]))
+	}
+
+	// Convert spanevents (sorted by name for deterministic output)
+	var spanEvents []count.MetricInfo
+	spanEventNames := make([]string, 0, len(cfg.SpanEvents))
+	for name := range cfg.SpanEvents {
+		spanEventNames = append(spanEventNames, name)
+	}
+	sort.Strings(spanEventNames)
+	for _, name := range spanEventNames {
+		spanEvents = append(spanEvents, toCountMetricInfo(name, cfg.SpanEvents[name]))
+	}
+
+	// Convert metrics (sorted by name for deterministic output)
+	var metrics []count.MetricInfo
+	metricNames := make([]string, 0, len(cfg.Metrics))
+	for name := range cfg.Metrics {
+		metricNames = append(metricNames, name)
+	}
+	sort.Strings(metricNames)
+	for _, name := range metricNames {
+		metrics = append(metrics, toCountMetricInfo(name, cfg.Metrics[name]))
+	}
+
+	// Convert datapoints (sorted by name for deterministic output)
+	var dataPoints []count.MetricInfo
+	dataPointNames := make([]string, 0, len(cfg.DataPoints))
+	for name := range cfg.DataPoints {
+		dataPointNames = append(dataPointNames, name)
+	}
+	sort.Strings(dataPointNames)
+	for _, name := range dataPointNames {
+		dataPoints = append(dataPoints, toCountMetricInfo(name, cfg.DataPoints[name]))
+	}
+
+	// Convert logs (sorted by name for deterministic output)
+	var logs []count.MetricInfo
+	logNames := make([]string, 0, len(cfg.Logs))
+	for name := range cfg.Logs {
+		logNames = append(logNames, name)
+	}
+	sort.Strings(logNames)
+	for _, name := range logNames {
+		logs = append(logs, toCountMetricInfo(name, cfg.Logs[name]))
+	}
+
+	return &count.Arguments{
+		Spans:      spans,
+		SpanEvents: spanEvents,
+		Metrics:    metrics,
+		DataPoints: dataPoints,
+		Logs:       logs,
+
+		Output: &otelcol.ConsumerArguments{
+			Metrics: ToTokenizedConsumers(nextMetrics),
+		},
+
+		DebugMetrics: common.DefaultValue[count.Arguments]().DebugMetrics,
+	}
+}
+
+func toCountMetricInfo(name string, info countconnector.MetricInfo) count.MetricInfo {
+	var attributes []count.AttributeConfig
+	for _, attr := range info.Attributes {
+		attributes = append(attributes, count.AttributeConfig{
+			Key:          attr.Key,
+			DefaultValue: attr.DefaultValue,
+		})
+	}
+
+	return count.MetricInfo{
+		Name:        name,
+		Description: info.Description,
+		Conditions:  info.Conditions,
+		Attributes:  attributes,
+	}
+}
diff --git a/internal/converter/internal/otelcolconvert/testdata/count.alloy b/internal/converter/internal/otelcolconvert/testdata/count.alloy
new file mode 100644
index 0000000000..a82eb7f6b1
--- /dev/null
+++ b/internal/converter/internal/otelcolconvert/testdata/count.alloy
@@ -0,0 +1,66 @@
+otelcol.receiver.otlp "default" {
+	grpc {
+		endpoint = "127.0.0.1:4317"
+	}
+
+	http {
+		endpoint = "127.0.0.1:4318"
+	}
+
+	output {
+		logs   = [otelcol.connector.count.default.input]
+		traces = [otelcol.connector.count.default.input]
+	}
+}
+
+otelcol.exporter.otlp "default" {
+	client {
+		endpoint = "localhost:4317"
+
+		tls {
+			insecure = true
+		}
+	}
+}
+
+otelcol.connector.count "default" {
+	spans {
+		name        = "http.span.count"
+		description = "HTTP GET requests"
+		conditions  = ["attributes[\"http.method\"] == \"GET\""]
+
+		attributes {
+			key           = "service.name"
+			default_value = "unknown"
+		}
+	}
+
+	spans {
+		name        = "my.span.count"
+		description = "Total spans"
+	}
+
+	spanevents {
+		name        = "trace.span.event.count"
+		description = "The number of span events observed."
+	}
+
+	metrics {
+		name        = "metric.count"
+		description = "The number of metrics observed."
+	}
+
+	datapoints {
+		name        = "metric.datapoint.count"
+		description = "The number of data points observed."
+	}
+
+	logs {
+		name        = "my.log.count"
+		description = "Total logs"
+	}
+
+	output {
+		metrics = [otelcol.exporter.otlp.default.input]
+	}
+}
diff --git a/internal/converter/internal/otelcolconvert/testdata/count.yaml b/internal/converter/internal/otelcolconvert/testdata/count.yaml
new file mode 100644
index 0000000000..c05dd802b6
--- /dev/null
+++ b/internal/converter/internal/otelcolconvert/testdata/count.yaml
@@ -0,0 +1,41 @@
+receivers:
+  otlp:
+    protocols:
+      grpc:
+        endpoint: 127.0.0.1:4317
+      http:
+        endpoint: 127.0.0.1:4318
+
+connectors:
+  count:
+    spans:
+      my.span.count:
+        description: "Total spans"
+      http.span.count:
+        description: "HTTP GET requests"
+        conditions:
+          - 'attributes["http.method"] == "GET"'
+        attributes:
+          - key: service.name
+            default_value: "unknown"
+    logs:
+      my.log.count:
+        description: "Total logs"
+
+exporters:
+  otlp:
+    endpoint: "localhost:4317"
+    tls:
+      insecure: true
+
+service:
+  pipelines:
+    traces:
+      receivers: [otlp]
+      exporters: [count]
+    logs:
+      receivers: [otlp]
+      exporters: [count]
+    metrics:
+      receivers: [count]
+      exporters: [otlp]