diff --git a/src/Normalizer/EntityReferenceRevisionItemNormalizer.php b/src/Normalizer/EntityReferenceRevisionItemNormalizer.php
index 5c63cf2..5833615 100644
--- a/src/Normalizer/EntityReferenceRevisionItemNormalizer.php
+++ b/src/Normalizer/EntityReferenceRevisionItemNormalizer.php
@@ -2,6 +2,7 @@
 
 namespace Drupal\entity_reference_revisions\Normalizer;
 
+use Drupal\entity_reference_revisions\EntityNeedsSaveInterface;
 use Drupal\entity_reference_revisions\Plugin\Field\FieldType\EntityReferenceRevisionsItem;
 use Drupal\hal\Normalizer\EntityReferenceItemNormalizer;
 
@@ -21,6 +22,23 @@ class EntityReferenceRevisionItemNormalizer extends EntityReferenceItemNormalize
    * {@inheritdoc}
    */
   protected function constructValue($data, $context) {
+    $field_item = $context['target_instance'];
+    $field_definition = $field_item->getFieldDefinition();
+    $target_type_id = $field_definition->getSetting('target_type');
+    $target_type = \Drupal::entityTypeManager()->getDefinition($target_type_id);
+
+    // If the target type has a revision parent id field and that is field is
+    // part of data, this is a composite normalization, denormalize it.
+    if ($target_type->get('entity_revision_parent_id_field') &&
+      isset($data[$target_type->get('entity_revision_parent_id_field')])) {
+      if ($target_entity = $this->serializer->denormalize($data, $target_type->getClass(), 'hal_json')) {
+        if ($target_entity instanceof EntityNeedsSaveInterface) {
+          $target_entity->needsSave();
+        }
+        return ['entity' => $target_entity];
+      }
+    }
+
     $value = parent::constructValue($data, $context);
     if ($value) {
       $value['target_revision_id'] = $data['target_revision_id'];
@@ -33,10 +51,27 @@ class EntityReferenceRevisionItemNormalizer extends EntityReferenceItemNormalize
    */
   public function normalize($field_item, $format = NULL, array $context = array()) {
     $data = parent::normalize($field_item, $format, $context);
-    $field_name = $field_item->getParent()->getName();
+    $target_entity = $field_item->get('entity')->getValue();
+
     $entity = $field_item->getEntity();
+    $field_name = $field_item->getParent()->getName();
     $field_uri = $this->linkManager->getRelationUri($entity->getEntityTypeId(), $entity->bundle(), $field_name, $context);
-    $data['_embedded'][$field_uri][0]['target_revision_id'] = $field_item->target_revision_id;
+
+    if ($target_entity->getEntityType()->get('entity_revision_parent_id_field')) {
+      $embedded_context = $context;
+      $embedded_context['included_fields'] = NULL;
+      $embedded = $this->serializer->normalize($target_entity, $format, $embedded_context);
+
+      // Restore lang key if it was set by our parent.
+      if (isset($data['_links'][$field_uri][0]['lang'])) {
+        $embedded['lang'] = $data['_links'][$field_uri][0]['lang'];
+      }
+
+      $data['_embedded'][$field_uri][0] = $embedded;
+    }
+    else {
+      $data['_embedded'][$field_uri][0]['target_revision_id'] = $field_item->target_revision_id;
+    }
     return $data;
   }
 
diff --git a/tests/src/Kernel/EntityReferenceRevisionsNormalizerTest.php b/tests/src/Kernel/EntityReferenceRevisionsNormalizerTest.php
new file mode 100644
index 0000000..e35ae92
--- /dev/null
+++ b/tests/src/Kernel/EntityReferenceRevisionsNormalizerTest.php
@@ -0,0 +1,193 @@
+<?php
+
+namespace Drupal\Tests\entity_reference_revisions\Kernel;
+
+use Drupal\Core\Field\FieldStorageDefinitionInterface;
+use Drupal\entity_composite_relationship_test\Entity\EntityTestCompositeRelationship;
+use Drupal\field\Entity\FieldConfig;
+use Drupal\field\Entity\FieldStorageConfig;
+use Drupal\KernelTests\Core\Entity\EntityKernelTestBase;
+use Drupal\node\Entity\Node;
+use Drupal\node\Entity\NodeType;
+use Drupal\simpletest\ContentTypeCreationTrait;
+use Drupal\simpletest\NodeCreationTrait;
+
+/**
+ * Tests the entity_reference_revisions normalizer.
+ *
+ * @group entity_reference_revisions
+ */
+class EntityReferenceRevisionsNormalizerTest extends EntityKernelTestBase {
+
+  use ContentTypeCreationTrait;
+  use NodeCreationTrait;
+
+  /**
+   * Modules to enable.
+   *
+   * @var array
+   */
+  public static $modules = [
+    'node',
+    'field',
+    'entity_reference_revisions',
+    'entity_composite_relationship_test',
+    'language',
+    'hal',
+    'serialization',
+    'rest',
+  ];
+
+  /**
+   * SerializerInterface which is used for serialization.
+   *
+   * @var \Symfony\Component\Serializer\Normalizer\NormalizerInterface
+   */
+  protected $serializer;
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp() {
+    parent::setUp();
+
+    $this->installEntitySchema('entity_test_composite');
+    $this->installSchema('node', ['node_access']);
+
+    // Create article content type.
+    NodeType::create([
+      'type' => 'article',
+      'name' => 'Article',
+    ])->save();
+
+    // Create the reference to the composite entity test for a nested composite
+    // entity test.
+    $field_storage = FieldStorageConfig::create([
+      'field_name' => 'composite_nested_reference',
+      'entity_type' => 'entity_test_composite',
+      'type' => 'entity_reference_revisions',
+      'settings' => [
+        'target_type' => 'entity_test_composite',
+      ],
+    ]);
+    $field_storage->save();
+    $field = FieldConfig::create([
+      'field_storage' => $field_storage,
+      'bundle' => 'entity_test_composite',
+      'translatable' => FALSE,
+    ]);
+    $field->save();
+
+    // Create the reference to the composite entity test.
+    $field_storage = FieldStorageConfig::create([
+      'field_name' => 'composite_reference',
+      'entity_type' => 'node',
+      'type' => 'entity_reference_revisions',
+      'settings' => [
+        'target_type' => 'entity_test_composite',
+      ],
+    ]);
+    $field_storage->save();
+    $field = FieldConfig::create([
+      'field_storage' => $field_storage,
+      'bundle' => 'article',
+      'translatable' => FALSE,
+    ]);
+    $field->save();
+
+    // Create a non-composite reference to a node.
+    $field_storage = FieldStorageConfig::create([
+      'field_name' => 'node_reference',
+      'entity_type' => 'node',
+      'type' => 'entity_reference_revisions',
+      'cardinality' => FieldStorageDefinitionInterface::CARDINALITY_UNLIMITED,
+      'settings' => [
+        'target_type' => 'node',
+      ],
+    ]);
+    $field_storage->save();
+    $field = FieldConfig::create([
+      'field_storage' => $field_storage,
+      'bundle' => 'article',
+      'translatable' => FALSE,
+    ]);
+    $field->save();
+
+    // Inject serializer.
+    $this->serializer = $this->container->get('serializer');
+  }
+
+  /**
+   * Tests the embedded paragraph when normalizing.
+   */
+  public function testEmbedEntityReference() {
+    // Create the test composite entity.
+    $nested_composite = EntityTestCompositeRelationship::create([
+      'name' => $nested_composite_name = $this->randomMachineName(),
+    ]);
+    $nested_composite->save();
+
+    $composite = EntityTestCompositeRelationship::create([
+      'name' => $composite_name = $this->randomMachineName(),
+      'composite_nested_reference' => $nested_composite,
+    ]);
+    $composite->save();
+
+    // Add 2 nodes for referencing.
+    $node_reference = Node::create([
+      'type' => 'article',
+      'title' => 'Referenced node',
+    ]);
+    $node_reference->save();
+    $node_reference2 = Node::create([
+      'type' => 'article',
+      'title' => 'Referenced node #2',
+    ]);
+    $node_reference2->save();
+
+    // Add content with the nested composite entity test and the 2 referenced
+    // nodes.
+    $node = Node::create([
+      'type' => 'article',
+      'title' => 'Normalizing paragraph test',
+      'node_reference' => [$node_reference, $node_reference2],
+      'composite_reference' => $composite,
+    ]);
+    $node->save();
+
+    // Check the serialization of embedded composite field.
+    $normalized = $this->serializer->normalize($node, 'hal_json');
+
+    // Check the id of the composite reference in the node.
+    $revision_id = $node->get('composite_reference')->target_revision_id;
+    $this->assertEquals($revision_id,
+      $normalized['_embedded']['http://localhost/rest/relation/node/article/composite_reference'][0]['id'][0]['value']);
+
+    // Check the id of the nested composite reference in the entity test
+    // composite.
+    $nested_revision_id = $composite->get('composite_nested_reference')->target_revision_id;
+    $this->assertEquals($nested_revision_id,
+      $normalized['_embedded']['http://localhost/rest/relation/node/article/composite_reference'][0]['_embedded']['http://localhost/rest/relation/entity_test_composite/entity_test_composite/composite_nested_reference'][0]['id'][0]['value']);
+
+    // Check the denormalization of the embedded composite field.
+    $nested_composite->delete();
+    $composite->delete();
+    $node->delete();
+    $node = $this->serializer->denormalize($normalized, Node::class, 'hal_json');
+    $node->save();
+
+    $node = Node::load($node->id());
+
+    // Check the id of the composite reference in the node.
+    $this->assertEquals($revision_id, $node->get('composite_reference')->target_revision_id);
+    $this->assertEquals($composite_name, $node->get('composite_reference')->entity->label());
+
+    // Check the id of the nested composite reference in the entity test
+    // composite.
+    $this->assertEquals($nested_revision_id,
+      $node->get('composite_reference')->entity->get('composite_nested_reference')->target_revision_id);
+    $this->assertEquals($nested_composite_name,
+      $node->get('composite_reference')->entity->get('composite_nested_reference')->entity->label());
+  }
+
+}