diff --git a/src/Objects/Serializers/Attributes/MapInputName.php b/src/Objects/Serializers/Attributes/MapInputName.php
new file mode 100644
index 0000000..7e55188
--- /dev/null
+++ b/src/Objects/Serializers/Attributes/MapInputName.php
@@ -0,0 +1,18 @@
+<?php
+/*
+ * Copyright (c) 2025. Encore Digital Group.
+ * All Rights Reserved.
+ */
+
+namespace EncoreDigitalGroup\StdLib\Objects\Serializers\Attributes;
+
+use Attribute;
+use EncoreDigitalGroup\StdLib\Objects\Serializers\Mappers\IPropertyMapper;
+
+#[Attribute(Attribute::TARGET_PROPERTY | Attribute::TARGET_CLASS)]
+class MapInputName
+{
+    public function __construct(
+        public string|IPropertyMapper $mapper
+    ) {}
+}
\ No newline at end of file
diff --git a/src/Objects/Serializers/Attributes/MapName.php b/src/Objects/Serializers/Attributes/MapName.php
new file mode 100644
index 0000000..2be8c2b
--- /dev/null
+++ b/src/Objects/Serializers/Attributes/MapName.php
@@ -0,0 +1,29 @@
+<?php
+/*
+ * Copyright (c) 2025. Encore Digital Group.
+ * All Rights Reserved.
+ */
+
+namespace EncoreDigitalGroup\StdLib\Objects\Serializers\Attributes;
+
+use Attribute;
+use EncoreDigitalGroup\StdLib\Objects\Serializers\Mappers\IPropertyMapper;
+
+/**
+ * @property string|IPropertyMapper $input Mapper used for deserialization operations
+ * @property string|IPropertyMapper $output Mapper used for serialization operations. Defaults to input.
+ */
+#[Attribute(Attribute::TARGET_PROPERTY | Attribute::TARGET_CLASS)]
+class MapName
+{
+    public function __construct(
+        public string|IPropertyMapper      $input,
+        public string|IPropertyMapper|null $output = null
+    )
+    {
+        /** @phpstan-ignore-next-line False positive from doc block */
+        if (is_null($this->output)) {
+            $this->output = $input;
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Objects/Serializers/Attributes/MapOutputName.php b/src/Objects/Serializers/Attributes/MapOutputName.php
new file mode 100644
index 0000000..14bdce9
--- /dev/null
+++ b/src/Objects/Serializers/Attributes/MapOutputName.php
@@ -0,0 +1,18 @@
+<?php
+/*
+ * Copyright (c) 2025. Encore Digital Group.
+ * All Rights Reserved.
+ */
+
+namespace EncoreDigitalGroup\StdLib\Objects\Serializers\Attributes;
+
+use Attribute;
+use EncoreDigitalGroup\StdLib\Objects\Serializers\Mappers\IPropertyMapper;
+
+#[Attribute(Attribute::TARGET_PROPERTY | Attribute::TARGET_CLASS)]
+class MapOutputName
+{
+    public function __construct(
+        public string|IPropertyMapper $mapper
+    ) {}
+}
\ No newline at end of file
diff --git a/src/Objects/Serializers/JsonSerializer.php b/src/Objects/Serializers/JsonSerializer.php
index 7013607..9f8ab26 100644
--- a/src/Objects/Serializers/JsonSerializer.php
+++ b/src/Objects/Serializers/JsonSerializer.php
@@ -1,12 +1,26 @@
 <?php
+/*
+ * Copyright (c) 2025. Encore Digital Group.
+ * All Rights Reserved.
+ */
 
 namespace EncoreDigitalGroup\StdLib\Objects\Serializers;
 
+use EncoreDigitalGroup\StdLib\Objects\Serializers\Attributes\MapInputName;
+use EncoreDigitalGroup\StdLib\Objects\Serializers\Attributes\MapName;
+use EncoreDigitalGroup\StdLib\Objects\Serializers\Attributes\MapOutputName;
+use EncoreDigitalGroup\StdLib\Objects\Serializers\Mappers\IPropertyMapper;
 use Illuminate\Support\Collection;
+use ReflectionClass;
+use ReflectionProperty;
+use RuntimeException;
 use Symfony\Component\Serializer\Encoder\JsonEncoder;
 
 class JsonSerializer extends AbstractSerializer
 {
+    private const string MAPPER_DIRECTION_INPUT = "input";
+    private const string MAPPER_DIRECTION_OUTPUT = "output";
+
     protected static Collection $normalizers;
 
     protected static function format(): string
@@ -18,4 +32,159 @@ protected static function encoders(): array
     {
         return [(new JsonEncoder)];
     }
+
+    public static function serialize(object $object): string
+    {
+        if (self::hasMapNameAttributes($object)) {
+            return self::serializeWithMapName($object);
+        }
+
+        return parent::serialize($object);
+    }
+
+    /** @param class-string $class */
+    public static function deserialize(string $class, string $data): mixed
+    {
+        if (self::hasMapNameAttributes($class)) {
+            return self::deserializeWithMapName($class, $data);
+        }
+
+        return parent::deserialize($class, $data);
+    }
+
+    /**
+     * @param class-string|object $classOrObject
+     */
+    private static function hasMapNameAttributes(string|object $classOrObject): bool
+    {
+        $reflection = new ReflectionClass($classOrObject);
+
+        if (!empty($reflection->getAttributes(MapName::class)) ||
+            !empty($reflection->getAttributes(MapInputName::class)) ||
+            !empty($reflection->getAttributes(MapOutputName::class))) {
+            return true;
+        }
+
+        foreach ($reflection->getProperties() as $property) {
+            if (!empty($property->getAttributes(MapName::class)) ||
+                !empty($property->getAttributes(MapInputName::class)) ||
+                !empty($property->getAttributes(MapOutputName::class))) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    private static function serializeWithMapName(object $object): string
+    {
+        $reflection = new ReflectionClass($object);
+        $data = [];
+
+        foreach ($reflection->getProperties() as $property) {
+            $property->setAccessible(true);
+            $propertyName = $property->getName();
+            $value = $property->getValue($object);
+
+            $mappedName = self::getMappedOutputName($property, $reflection) ?? $propertyName;
+            $data[$mappedName] = $value;
+        }
+
+        $json = json_encode($data);
+        if ($json === false) {
+            throw new RuntimeException('Failed to encode JSON');
+        }
+
+        return $json;
+    }
+
+    /**
+     * @param class-string $class
+     */
+    private static function deserializeWithMapName(string $class, string $jsonData): mixed
+    {
+        $data = json_decode($jsonData, true);
+        $reflection = new ReflectionClass($class);
+        $constructor = $reflection->getConstructor();
+
+        if (!$constructor) {
+            return $reflection->newInstance();
+        }
+
+        $args = [];
+        foreach ($constructor->getParameters() as $parameter) {
+            $args[] = self::resolveParameterValue($parameter, $reflection, $data);
+        }
+
+        return $reflection->newInstanceArgs($args);
+    }
+
+    private static function resolveParameterValue(\ReflectionParameter $parameter, ReflectionClass $reflection, array $data): mixed
+    {
+        $parameterName = $parameter->getName();
+        $property = $reflection->hasProperty($parameterName) ? $reflection->getProperty($parameterName) : null;
+
+        if ($property) {
+            $mappedName = self::getMappedInputName($property, $reflection) ?? $parameterName;
+            $keyToUse = $mappedName;
+        } else {
+            $keyToUse = $parameterName;
+        }
+
+        if (array_key_exists($keyToUse, $data)) {
+            return $data[$keyToUse];
+        }
+
+        return $parameter->isDefaultValueAvailable() ? $parameter->getDefaultValue() : null;
+    }
+
+    private static function getMappedOutputName(ReflectionProperty $property, ReflectionClass $classReflection): ?string
+    {
+        return self::getMapperForDirection($property, $property->getName(), self::MAPPER_DIRECTION_OUTPUT)
+            ?? self::getMapperForDirection($classReflection, $property->getName(), self::MAPPER_DIRECTION_OUTPUT);
+    }
+
+    private static function getMappedInputName(ReflectionProperty $property, ReflectionClass $classReflection): ?string
+    {
+        return self::getMapperForDirection($property, $property->getName(), self::MAPPER_DIRECTION_INPUT)
+            ?? self::getMapperForDirection($classReflection, $property->getName(), self::MAPPER_DIRECTION_INPUT);
+    }
+
+    private static function getMapperResult(string|IPropertyMapper $mapper, string $propertyName): string
+    {
+        if (is_string($mapper)) {
+            if (class_exists($mapper)) {
+                $mapperInstance = new $mapper();
+                if ($mapperInstance instanceof IPropertyMapper) {
+                    return $mapperInstance->map($propertyName);
+                }
+            }
+            return $mapper;
+        }
+
+        return $mapper->map($propertyName);
+    }
+
+    private static function getMapperForDirection(ReflectionProperty|ReflectionClass $reflector, string $propertyName, string $direction): ?string
+    {
+        $specificAttributeClass = $direction === self::MAPPER_DIRECTION_INPUT ? MapInputName::class : MapOutputName::class;
+
+        $specificAttributes = $reflector->getAttributes($specificAttributeClass);
+        if (!empty($specificAttributes)) {
+            return self::getMapperResult($specificAttributes[0]->newInstance()->mapper, $propertyName);
+        }
+
+        $mapNameAttributes = $reflector->getAttributes(MapName::class);
+        if (!empty($mapNameAttributes)) {
+            $mapNameInstance = $mapNameAttributes[0]->newInstance();
+            $mapper = $direction === self::MAPPER_DIRECTION_OUTPUT
+                ? ($mapNameInstance->output ?? $mapNameInstance->input)
+                : $mapNameInstance->input;
+            if ($mapper !== null) {
+                return self::getMapperResult($mapper, $propertyName);
+            }
+        }
+
+        return null;
+    }
 }
\ No newline at end of file
diff --git a/src/Objects/Serializers/Mappers/CamelCaseMapper.php b/src/Objects/Serializers/Mappers/CamelCaseMapper.php
new file mode 100644
index 0000000..01abc95
--- /dev/null
+++ b/src/Objects/Serializers/Mappers/CamelCaseMapper.php
@@ -0,0 +1,17 @@
+<?php
+/*
+ * Copyright (c) 2025. Encore Digital Group.
+ * All Rights Reserved.
+ */
+
+namespace EncoreDigitalGroup\StdLib\Objects\Serializers\Mappers;
+
+use EncoreDigitalGroup\StdLib\Objects\Support\Types\Str;
+
+class CamelCaseMapper implements IPropertyMapper
+{
+    public function map(string $propertyName): string
+    {
+        return Str::camel($propertyName);
+    }
+}
\ No newline at end of file
diff --git a/src/Objects/Serializers/Mappers/IPropertyMapper.php b/src/Objects/Serializers/Mappers/IPropertyMapper.php
new file mode 100644
index 0000000..a76510e
--- /dev/null
+++ b/src/Objects/Serializers/Mappers/IPropertyMapper.php
@@ -0,0 +1,12 @@
+<?php
+/*
+ * Copyright (c) 2025. Encore Digital Group.
+ * All Rights Reserved.
+ */
+
+namespace EncoreDigitalGroup\StdLib\Objects\Serializers\Mappers;
+
+interface IPropertyMapper
+{
+    public function map(string $propertyName): string;
+}
\ No newline at end of file
diff --git a/src/Objects/Serializers/Mappers/PascalCaseMapper.php b/src/Objects/Serializers/Mappers/PascalCaseMapper.php
new file mode 100644
index 0000000..949d661
--- /dev/null
+++ b/src/Objects/Serializers/Mappers/PascalCaseMapper.php
@@ -0,0 +1,17 @@
+<?php
+/*
+ * Copyright (c) 2025. Encore Digital Group.
+ * All Rights Reserved.
+ */
+
+namespace EncoreDigitalGroup\StdLib\Objects\Serializers\Mappers;
+
+use EncoreDigitalGroup\StdLib\Objects\Support\Types\Str;
+
+class PascalCaseMapper implements IPropertyMapper
+{
+    public function map(string $propertyName): string
+    {
+        return Str::studly($propertyName);
+    }
+}
\ No newline at end of file
diff --git a/src/Objects/Serializers/Mappers/ProvidedNameMapper.php b/src/Objects/Serializers/Mappers/ProvidedNameMapper.php
new file mode 100644
index 0000000..fcb2de6
--- /dev/null
+++ b/src/Objects/Serializers/Mappers/ProvidedNameMapper.php
@@ -0,0 +1,17 @@
+<?php
+/*
+ * Copyright (c) 2025. Encore Digital Group.
+ * All Rights Reserved.
+ */
+
+namespace EncoreDigitalGroup\StdLib\Objects\Serializers\Mappers;
+
+readonly class ProvidedNameMapper implements IPropertyMapper
+{
+    public function __construct(private string $mappedName) {}
+
+    public function map(string $propertyName): string
+    {
+        return $this->mappedName;
+    }
+}
\ No newline at end of file
diff --git a/src/Objects/Serializers/Mappers/SnakeCaseMapper.php b/src/Objects/Serializers/Mappers/SnakeCaseMapper.php
new file mode 100644
index 0000000..ac6b2e0
--- /dev/null
+++ b/src/Objects/Serializers/Mappers/SnakeCaseMapper.php
@@ -0,0 +1,17 @@
+<?php
+/*
+ * Copyright (c) 2025. Encore Digital Group.
+ * All Rights Reserved.
+ */
+
+namespace EncoreDigitalGroup\StdLib\Objects\Serializers\Mappers;
+
+use EncoreDigitalGroup\StdLib\Objects\Support\Types\Str;
+
+class SnakeCaseMapper implements IPropertyMapper
+{
+    public function map(string $propertyName): string
+    {
+        return Str::snake($propertyName);
+    }
+}
\ No newline at end of file
diff --git a/tests/Unit/SerializerTests/JsonSerializerTest.php b/tests/Unit/SerializerTests/JsonSerializerTest.php
index a211345..faaf53d 100644
--- a/tests/Unit/SerializerTests/JsonSerializerTest.php
+++ b/tests/Unit/SerializerTests/JsonSerializerTest.php
@@ -1,6 +1,15 @@
 <?php
+/*
+ * Copyright (c) 2025. Encore Digital Group.
+ * All Rights Reserved.
+ */
 
+use EncoreDigitalGroup\StdLib\Objects\Serializers\Attributes\MapInputName;
+use EncoreDigitalGroup\StdLib\Objects\Serializers\Attributes\MapName;
+use EncoreDigitalGroup\StdLib\Objects\Serializers\Attributes\MapOutputName;
 use EncoreDigitalGroup\StdLib\Objects\Serializers\JsonSerializer;
+use EncoreDigitalGroup\StdLib\Objects\Serializers\Mappers\ProvidedNameMapper;
+use EncoreDigitalGroup\StdLib\Objects\Serializers\Mappers\SnakeCaseMapper;
 
 class TestObject
 {
@@ -14,6 +23,57 @@ public function __construct(string $name, int $age)
     }
 }
 
+class MapNameTestObject
+{
+    public function __construct(
+        #[MapName(SnakeCaseMapper::class)]
+        public string $firstName,
+        #[MapName(SnakeCaseMapper::class)]
+        public string $lastName,
+        public int    $age
+    ) {}
+}
+
+class MapInputOutputTestObject
+{
+    public function __construct(
+        #[MapInputName('first_name')]
+        #[MapOutputName('full_name')]
+        public string $name,
+        public int    $age
+    ) {}
+}
+
+class ProvidedNameTestObject
+{
+    public function __construct(
+        #[MapName(new ProvidedNameMapper('custom_field_name'))]
+        public string $fieldName,
+        public string $otherField
+    ) {}
+}
+
+class MapNameInputOutputTestObject
+{
+    public function __construct(
+        #[MapName(input: 'input_name', output: 'output_name')]
+        public string $name,
+        #[MapName(input: SnakeCaseMapper::class)]
+        public string $firstName,
+        public int    $age
+    ) {}
+}
+
+#[MapName(SnakeCaseMapper::class)]
+class ClassLevelMapNameObject
+{
+    public function __construct(
+        public string $firstName,
+        public string $lastName,
+        public int    $userAge
+    ) {}
+}
+
 describe("JsonSerializer Tests", function () {
     test('JsonSerializer can serialize an object', function () {
         $object = new TestObject('John Doe', 30);
@@ -34,4 +94,118 @@ public function __construct(string $name, int $age)
             ->and($object->name)->toBe('John Doe')
             ->and($object->age)->toBe(30);
     });
+
+    test('JsonSerializer uses MapName attributes for serialization', function () {
+        $object = new MapNameTestObject('John', 'Doe', 30);
+        $json = JsonSerializer::serialize($object);
+
+        expect($json)->toBeJson()
+            ->and(json_decode($json, true))->toMatchArray([
+                'first_name' => 'John',
+                'last_name' => 'Doe',
+                'age' => 30,
+            ]);
+    });
+
+    test('JsonSerializer uses MapName attributes for deserialization', function () {
+        $json = '{"first_name":"John","last_name":"Doe","age":30}';
+        $object = JsonSerializer::deserialize(MapNameTestObject::class, $json);
+
+        expect($object)->toBeInstanceOf(MapNameTestObject::class)
+            ->and($object->firstName)->toBe('John')
+            ->and($object->lastName)->toBe('Doe')
+            ->and($object->age)->toBe(30);
+    });
+
+    test('JsonSerializer uses separate MapInputName and MapOutputName attributes', function () {
+        $object = new MapInputOutputTestObject('John Doe', 30);
+        $json = JsonSerializer::serialize($object);
+
+        expect($json)->toBeJson()
+            ->and(json_decode($json, true))->toMatchArray([
+                'full_name' => 'John Doe',
+                'age' => 30,
+            ]);
+
+        $inputJson = '{"first_name":"Jane Smith","age":25}';
+        $deserializedObject = JsonSerializer::deserialize(MapInputOutputTestObject::class, $inputJson);
+
+        expect($deserializedObject)->toBeInstanceOf(MapInputOutputTestObject::class)
+            ->and($deserializedObject->name)->toBe('Jane Smith')
+            ->and($deserializedObject->age)->toBe(25);
+    });
+
+    test('JsonSerializer uses ProvidedNameMapper for custom field names', function () {
+        $object = new ProvidedNameTestObject('test value', 'other value');
+        $json = JsonSerializer::serialize($object);
+
+        expect($json)->toBeJson()
+            ->and(json_decode($json, true))->toMatchArray([
+                'custom_field_name' => 'test value',
+                'otherField' => 'other value',
+            ]);
+
+        $inputJson = '{"custom_field_name":"new value","otherField":"other new value"}';
+        $deserializedObject = JsonSerializer::deserialize(ProvidedNameTestObject::class, $inputJson);
+
+        expect($deserializedObject)->toBeInstanceOf(ProvidedNameTestObject::class)
+            ->and($deserializedObject->fieldName)->toBe('new value')
+            ->and($deserializedObject->otherField)->toBe('other new value');
+    });
+
+    test('JsonSerializer uses class-level MapName attributes', function () {
+        $object = new ClassLevelMapNameObject('John', 'Doe', 30);
+        $json = JsonSerializer::serialize($object);
+
+        expect($json)->toBeJson()
+            ->and(json_decode($json, true))->toMatchArray([
+                'first_name' => 'John',
+                'last_name' => 'Doe',
+                'user_age' => 30,
+            ]);
+
+        $inputJson = '{"first_name":"Jane","last_name":"Smith","user_age":25}';
+        $deserializedObject = JsonSerializer::deserialize(ClassLevelMapNameObject::class, $inputJson);
+
+        expect($deserializedObject)->toBeInstanceOf(ClassLevelMapNameObject::class)
+            ->and($deserializedObject->firstName)->toBe('Jane')
+            ->and($deserializedObject->lastName)->toBe('Smith')
+            ->and($deserializedObject->userAge)->toBe(25);
+    });
+
+    test('JsonSerializer uses MapName with input and output parameters', function () {
+        $object = new MapNameInputOutputTestObject('John Doe', 'Jane', 30);
+        $json = JsonSerializer::serialize($object);
+
+        expect($json)->toBeJson()
+            ->and(json_decode($json, true))->toMatchArray([
+                'output_name' => 'John Doe',
+                'first_name' => 'Jane',
+                'age' => 30,
+            ]);
+
+        $inputJson = '{"input_name":"Jane Smith","first_name":"Mary","age":25}';
+        $deserializedObject = JsonSerializer::deserialize(MapNameInputOutputTestObject::class, $inputJson);
+
+        expect($deserializedObject)->toBeInstanceOf(MapNameInputOutputTestObject::class)
+            ->and($deserializedObject->name)->toBe('Jane Smith')
+            ->and($deserializedObject->firstName)->toBe('Mary')
+            ->and($deserializedObject->age)->toBe(25);
+    });
+
+    test('JsonSerializer falls back to Symfony serializer when no MapName attributes are present', function () {
+        $object = new TestObject('John Doe', 30);
+        $json = JsonSerializer::serialize($object);
+
+        expect($json)->toBeJson()
+            ->and(json_decode($json, true))->toMatchArray([
+                'name' => 'John Doe',
+                'age' => 30,
+            ]);
+
+        $deserializedObject = JsonSerializer::deserialize(TestObject::class, $json);
+        expect($deserializedObject)->toBeInstanceOf(TestObject::class)
+            ->and($deserializedObject->name)->toBe('John Doe')
+            ->and($deserializedObject->age)->toBe(30);
+    });
 });
\ No newline at end of file