diff --git a/bumble/profiles/vocs.py b/bumble/profiles/vocs.py
new file mode 100644
index 00000000..71210d3a
--- /dev/null
+++ b/bumble/profiles/vocs.py
@@ -0,0 +1,244 @@
+# Copyright 2024 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+# -----------------------------------------------------------------------------
+# Imports
+# -----------------------------------------------------------------------------
+import struct
+
+from typing import Optional
+
+from bumble import att
+from bumble import utils
+from bumble import device
+from bumble import gatt
+from bumble import gatt_client
+from bumble.profiles.bap import AudioLocation
+
+
+# -----------------------------------------------------------------------------
+# Constants
+# -----------------------------------------------------------------------------
+
+MIN_VOLUME_OFFSET = -255
+MAX_VOLUME_OFFSET = 255
+CHANGE_COUNTER_MAX_VALUE = 0xFF
+
+SET_VOLUME_OFFSET_OPCODE = 0x01
+
+
+class ErrorCode(utils.OpenIntEnum):
+    """
+    See Volume Offset Control Service 1.6. Application error codes.
+    """
+
+    INVALID_CHANGE_COUNTER = 0x80
+    OPCODE_NOT_SUPPORTED = 0x81
+    VALUE_OUT_OF_RANGE = 0x82
+
+
+# -----------------------------------------------------------------------------
+class VolumeOffsetControlService(gatt.TemplateService):
+    UUID = gatt.GATT_VOLUME_OFFSET_CONTROL_SERVICE
+
+    volume_offset_state: gatt.Characteristic
+    audio_location: gatt.Characteristic
+    volume_offset_control_point: gatt.Characteristic
+    audio_output_description: gatt.Characteristic
+
+    def __init__(
+        self,
+        volume_offset: int = 0,
+        change_counter: int = 0,
+        audio_channel_location: AudioLocation = AudioLocation.NOT_ALLOWED,
+        audio_output_description_value: str = '',
+    ) -> None:
+
+        self.volume_offset = volume_offset
+        self.change_counter = change_counter
+        self.audio_channel_location = audio_channel_location
+        self.audio_output_description_value = audio_output_description_value
+
+        characteristics = []
+
+        self.volume_offset_state = gatt.Characteristic(
+            uuid=gatt.GATT_VOLUME_OFFSET_STATE_CHARACTERISTIC,
+            properties=(
+                gatt.Characteristic.Properties.READ
+                | gatt.Characteristic.Properties.NOTIFY
+            ),
+            permissions=gatt.Characteristic.Permissions.READ_REQUIRES_ENCRYPTION,
+            value=gatt.CharacteristicValue(read=self._on_read_volume_offset_state),
+        )
+        characteristics.append(self.volume_offset_state)
+
+        self.audio_location = gatt.Characteristic(
+            uuid=gatt.GATT_AUDIO_LOCATION_CHARACTERISTIC,
+            properties=(
+                gatt.Characteristic.Properties.READ
+                | gatt.Characteristic.Properties.NOTIFY
+                | gatt.Characteristic.Properties.WRITE_WITHOUT_RESPONSE
+            ),
+            permissions=(
+                gatt.Characteristic.Permissions.READ_REQUIRES_ENCRYPTION
+                | gatt.Characteristic.Permissions.WRITE_REQUIRES_ENCRYPTION
+            ),
+            value=gatt.CharacteristicValue(
+                read=self._on_read_audio_location,
+                write=self._on_write_audio_location,
+            ),
+        )
+        characteristics.append(self.audio_location)
+
+        self.volume_offset_control_point = gatt.Characteristic(
+            uuid=gatt.GATT_VOLUME_OFFSET_CONTROL_POINT_CHARACTERISTIC,
+            properties=gatt.Characteristic.Properties.WRITE,
+            permissions=gatt.Characteristic.Permissions.WRITE_REQUIRES_ENCRYPTION,
+            value=gatt.CharacteristicValue(
+                write=self._on_write_volume_offset_control_point
+            ),
+        )
+        characteristics.append(self.volume_offset_control_point)
+
+        self.audio_output_description = gatt.Characteristic(
+            uuid=gatt.GATT_AUDIO_OUTPUT_DESCRIPTION_CHARACTERISTIC,
+            properties=(
+                gatt.Characteristic.Properties.READ
+                | gatt.Characteristic.Properties.NOTIFY
+                | gatt.Characteristic.Properties.WRITE_WITHOUT_RESPONSE
+            ),
+            permissions=(
+                gatt.Characteristic.Permissions.READ_REQUIRES_ENCRYPTION
+                | gatt.Characteristic.Permissions.WRITE_REQUIRES_ENCRYPTION
+            ),
+            value=gatt.CharacteristicValue(
+                read=self._on_read_audio_output_description,
+                write=self._on_write_audio_output_description,
+            ),
+        )
+        characteristics.append(self.audio_output_description)
+
+        super().__init__(characteristics=characteristics, primary=False)
+
+    @property
+    def volume_offset_state_bytes(self) -> bytes:
+        return struct.pack('<hB', self.volume_offset, self.change_counter)
+
+    @volume_offset_state_bytes.setter
+    def volume_offset_state_bytes(self, new_value: bytes) -> None:
+        self.volume_offset, self.change_counter = struct.unpack('<hB', new_value)
+
+    def _on_read_volume_offset_state(
+        self, _connection: Optional[device.Connection]
+    ) -> bytes:
+        return self.volume_offset_state_bytes
+
+    @property
+    def audio_location_bytes(self) -> bytes:
+        return struct.pack('<I', self.audio_channel_location)
+
+    @audio_location_bytes.setter
+    def audio_location_bytes(self, new_value: bytes) -> None:
+        self.audio_channel_location = struct.unpack('<I', new_value)[0]
+
+    def _on_read_audio_location(
+        self, _connection: Optional[device.Connection]
+    ) -> bytes:
+        return self.audio_location_bytes
+
+    async def _on_write_audio_location(
+        self, connection: Optional[device.Connection], value: bytes
+    ) -> None:
+        assert connection
+
+        self.audio_location_bytes = value
+        await connection.device.notify_subscribers(
+            attribute=self.audio_channel_location,
+            value=self.audio_location_bytes,
+        )
+        self.emit('audio_location_change')
+
+    async def _on_write_volume_offset_control_point(
+        self, connection: Optional[device.Connection], value: bytes
+    ) -> None:
+        assert connection
+
+        opcode = value[0]
+
+        if opcode != SET_VOLUME_OFFSET_OPCODE:
+            raise att.ATT_Error(ErrorCode.OPCODE_NOT_SUPPORTED)
+
+        change_counter, volume_offset = struct.unpack('<Bh', value[1:])
+
+        if change_counter != self.change_counter:
+            raise att.ATT_Error(ErrorCode.INVALID_CHANGE_COUNTER)
+
+        if not MIN_VOLUME_OFFSET <= volume_offset <= MAX_VOLUME_OFFSET:
+            raise att.ATT_Error(ErrorCode.VALUE_OUT_OF_RANGE)
+
+        self.volume_offset, self.change_counter = (
+            volume_offset,
+            (self.change_counter + 1) % (CHANGE_COUNTER_MAX_VALUE + 1),
+        )
+        await connection.device.notify_subscribers(
+            attribute=self.volume_offset_state,
+            value=self.volume_offset_state_bytes,
+        )
+        self.emit('volume_offset_state_change')
+
+    def _on_read_audio_output_description(self, _connection) -> bytes:
+        return self.audio_output_description_value.encode('utf-8')
+
+    async def _on_write_audio_output_description(self, connection, value) -> None:
+        self.audio_output_description_value = value.decode('utf-8')
+        await connection.device.notify_subscribers(
+            attribute=self.audio_output_description,
+            value=self.audio_output_description_value.encode('utf-8'),
+        )
+        self.emit('audio_output_description_change')
+
+
+# -----------------------------------------------------------------------------
+# Client
+# -----------------------------------------------------------------------------
+class VolumeOffsetControlServiceProxy(gatt_client.ProfileServiceProxy):
+    SERVICE_CLASS = VolumeOffsetControlService
+
+    volume_offset_control_point: gatt_client.CharacteristicProxy
+
+    def __init__(self, service_proxy: gatt_client.ServiceProxy) -> None:
+        self.service_proxy = service_proxy
+
+        self.volume_offset_state = gatt.PackedCharacteristicAdapter(
+            service_proxy.get_characteristics_by_uuid(
+                gatt.GATT_VOLUME_OFFSET_STATE_CHARACTERISTIC
+            )[0],
+            '<hB',
+        )
+
+        self.audio_location = gatt.PackedCharacteristicAdapter(
+            service_proxy.get_characteristics_by_uuid(
+                gatt.GATT_AUDIO_LOCATION_CHARACTERISTIC
+            )[0],
+            '<I',
+        )
+
+        self.volume_offset_control_point = service_proxy.get_characteristics_by_uuid(
+            gatt.GATT_VOLUME_OFFSET_CONTROL_POINT_CHARACTERISTIC
+        )[0]
+
+        self.audio_output_description = service_proxy.get_characteristics_by_uuid(
+            gatt.GATT_AUDIO_OUTPUT_DESCRIPTION_CHARACTERISTIC
+        )[0]
diff --git a/tests/vocs_test.py b/tests/vocs_test.py
new file mode 100644
index 00000000..95f11c54
--- /dev/null
+++ b/tests/vocs_test.py
@@ -0,0 +1,167 @@
+# Copyright 2024 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+# -----------------------------------------------------------------------------
+# Imports
+# -----------------------------------------------------------------------------
+import pytest
+import pytest_asyncio
+import struct
+
+from bumble import device
+
+from bumble.att import ATT_Error
+
+
+from bumble.profiles.vcp import VolumeControlService, VolumeControlServiceProxy
+from bumble.profiles.vocs import (
+    VolumeOffsetControlService,
+    ErrorCode,
+    MIN_VOLUME_OFFSET,
+    MAX_VOLUME_OFFSET,
+    SET_VOLUME_OFFSET_OPCODE,
+    VolumeOffsetControlServiceProxy,
+)
+from bumble.profiles.bap import AudioLocation
+
+from .test_utils import TwoDevices
+
+
+# -----------------------------------------------------------------------------
+# Tests
+# -----------------------------------------------------------------------------
+vocs_service = VolumeOffsetControlService()
+vcp_service = VolumeControlService(included_services=[vocs_service])
+
+
+@pytest_asyncio.fixture
+async def vocs_client():
+    devices = TwoDevices()
+    devices[0].add_service(vcp_service)
+
+    await devices.setup_connection()
+
+    assert devices.connections[0]
+    assert devices.connections[1]
+
+    devices.connections[0].encryption = 1
+    devices.connections[1].encryption = 1
+
+    peer = device.Peer(devices.connections[1])
+
+    vcp_client = await peer.discover_service_and_create_proxy(VolumeControlServiceProxy)
+
+    assert vcp_client
+    included_services = await peer.discover_included_services(vcp_client.service_proxy)
+    assert included_services
+    vocs_service_discovered = included_services[0]
+    await peer.discover_characteristics(service=vocs_service_discovered)
+    vocs_client = VolumeOffsetControlServiceProxy(vocs_service_discovered)
+
+    yield vocs_client
+
+
+# -----------------------------------------------------------------------------
+@pytest.mark.asyncio
+async def test_init_service(vocs_client: VolumeOffsetControlServiceProxy):
+    assert await vocs_client.volume_offset_state.read_value() == (0, 0)
+    assert await vocs_client.audio_location.read_value() == AudioLocation.NOT_ALLOWED
+    description = await vocs_client.audio_output_description.read_value()
+    assert description.decode('utf-8') == ''
+
+
+@pytest.mark.asyncio
+async def test_wrong_opcode_raise_error(vocs_client: VolumeOffsetControlServiceProxy):
+    with pytest.raises(ATT_Error) as e:
+        await vocs_client.volume_offset_control_point.write_value(
+            bytes(
+                [
+                    0xFF,
+                ]
+            ),
+            with_response=True,
+        )
+
+    assert e.value.error_code == ErrorCode.OPCODE_NOT_SUPPORTED
+
+
+@pytest.mark.asyncio
+async def test_wrong_change_counter_raise_error(
+    vocs_client: VolumeOffsetControlServiceProxy,
+):
+    initial_counter = vocs_service.change_counter
+    wrong_counter = initial_counter + 1
+
+    with pytest.raises(ATT_Error) as e:
+        await vocs_client.volume_offset_control_point.write_value(
+            struct.pack('<BBh', SET_VOLUME_OFFSET_OPCODE, wrong_counter, 0),
+            with_response=True,
+        )
+    assert e.value.error_code == ErrorCode.INVALID_CHANGE_COUNTER
+
+    offset, counter = await vocs_client.volume_offset_state.read_value()
+    assert counter == initial_counter
+
+
+@pytest.mark.asyncio
+async def test_wrong_volume_offset_raise_error(
+    vocs_client: VolumeOffsetControlServiceProxy,
+):
+    invalid_offset_low = MIN_VOLUME_OFFSET - 1
+    invalid_offset_high = MAX_VOLUME_OFFSET + 1
+
+    with pytest.raises(ATT_Error) as e_low:
+        await vocs_client.volume_offset_control_point.write_value(
+            struct.pack('<BBh', SET_VOLUME_OFFSET_OPCODE, 0, invalid_offset_low),
+            with_response=True,
+        )
+    assert e_low.value.error_code == ErrorCode.VALUE_OUT_OF_RANGE
+
+    with pytest.raises(ATT_Error) as e_high:
+        await vocs_client.volume_offset_control_point.write_value(
+            struct.pack('<BBh', SET_VOLUME_OFFSET_OPCODE, 0, invalid_offset_high),
+            with_response=True,
+        )
+    assert e_high.value.error_code == ErrorCode.VALUE_OUT_OF_RANGE
+
+
+@pytest.mark.asyncio
+async def test_set_volume_offset(vocs_client: VolumeOffsetControlServiceProxy):
+    await vocs_client.volume_offset_control_point.write_value(
+        struct.pack('<BBh', SET_VOLUME_OFFSET_OPCODE, 0, -255),
+    )
+    assert await vocs_client.volume_offset_state.read_value() == (-255, 1)
+
+
+@pytest.mark.asyncio
+async def test_set_audio_channel_location(vocs_client: VolumeOffsetControlServiceProxy):
+    new_audio_location = AudioLocation.FRONT_LEFT
+
+    await vocs_client.audio_location.write_value(new_audio_location)
+
+    location = await vocs_client.audio_location.read_value()
+    assert location == new_audio_location
+
+
+@pytest.mark.asyncio
+async def test_set_audio_output_description(
+    vocs_client: VolumeOffsetControlServiceProxy,
+):
+    new_description = 'Left Speaker'.encode('utf-8')
+
+    await vocs_client.audio_output_description.write_value(new_description)
+
+    description = await vocs_client.audio_output_description.read_value()
+    assert description == new_description