diff --git a/README.md b/README.md
index c5d7681..b31b74d 100644
--- a/README.md
+++ b/README.md
@@ -28,3 +28,19 @@ The list of endpoints then looks like the following:
 * `/jsonapi/node/article/{UUID}`: Exposes an individual article
 * `/jsonapi/block`: Exposes a collection of blocks
 * `/jsonapi/block/{block}`: Exposes an individual block
+
+## Development usage
+
+It is also possible to obtain the JSON API representation of a supported entity:
+
+  ```
+  // For a given $entity object.
+  $nested_array = \Drupal::service('jsonapi.entity.to_jsonapi')->normalize($entity);
+  ```
+
+Should it be needed, the raw string itself can be obtained:
+
+  ```
+  // For a given $entity object.
+  $json_string = \Drupal::service('jsonapi.entity.to_jsonapi')->serialize($entity);
+  ```
diff --git a/jsonapi.services.yml b/jsonapi.services.yml
index 874d38b..458d8ea 100644
--- a/jsonapi.services.yml
+++ b/jsonapi.services.yml
@@ -106,6 +106,10 @@ services:
       # middleware (priority 200)has the opportunity to respond.
       - { name: http_middleware, priority: 201 }
 
+  jsonapi.entity.to_jsonapi:
+    class: Drupal\jsonapi\EntityToJsonApi
+    arguments: ['@serializer', '@jsonapi.resource_type.repository', '@current_user']
+
   logger.channel.jsonapi:
     parent: logger.channel_base
     arguments: ['jsonapi']
diff --git a/src/EntityToJsonApi.php b/src/EntityToJsonApi.php
new file mode 100644
index 0000000..35e534c
--- /dev/null
+++ b/src/EntityToJsonApi.php
@@ -0,0 +1,107 @@
+<?php
+
+namespace Drupal\jsonapi;
+
+use Drupal\Core\Entity\EntityInterface;
+use Drupal\Core\Session\AccountProxyInterface;
+use Drupal\Core\Cache\CacheableMetadata;
+use Drupal\jsonapi\Resource\JsonApiDocumentTopLevel;
+use Drupal\jsonapi\ResourceType\ResourceTypeRepository;
+use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\Serializer\Serializer;
+
+/**
+ * Simplifies the process of generating a JSON API version of an entity.
+ */
+class EntityToJsonApi {
+
+  /**
+   * The currently logged in user.
+   *
+   * @var \Drupal\Core\Session\AccountProxyInterface
+   */
+  protected $currentUser;
+
+  /**
+   * Serializer object.
+   *
+   * @var \Symfony\Component\Serializer\Serializer
+   */
+  protected $serializer;
+
+  /**
+   * @var \Drupal\jsonapi\ResourceType\ResourceTypeRepository
+   */
+  protected $resourceTypeRepository;
+
+  /**
+   * EntityToJsonApi constructor.
+   *
+   * @param \Symfony\Component\Serializer\Serializer $serializer
+   *   The serializer.
+   * @param \Drupal\Core\Session\AccountProxyInterface $current_user
+   *   The currently logged in user.
+   */
+  public function __construct(Serializer $serializer, ResourceTypeRepository $resource_type_repository, AccountProxyInterface $current_user) {
+    $this->serializer = $serializer;
+    $this->resourceTypeRepository = $resource_type_repository;
+    $this->currentUser = $current_user;
+  }
+
+  /**
+   * Return the requested entity as a raw string.
+   *
+   * @param \Drupal\Core\Entity\EntityInterface $entity
+   *   The entity to generate the JSON from.
+   *
+   * @return string
+   *   The raw JSON string of the requested resource.
+   */
+  public function serialize(EntityInterface $entity) {
+    // TODO: Supporting includes requires adding the 'include' query string.
+    return $this->serializer->serialize(new JsonApiDocumentTopLevel($entity),
+      'api_json',
+      $this->calculateContext($entity)
+    );
+  }
+
+  /**
+   * Return the requested entity as an structured array.
+   *
+   * @param \Drupal\Core\Entity\EntityInterface $entity
+   *   The entity to generate the JSON from.
+   *
+   * @return array
+   *   The JSON structure of the requested resource.
+   */
+  public function normalize(EntityInterface $entity) {
+    return $this->serializer->normalize(new JsonApiDocumentTopLevel($entity),
+      'api_json',
+      $this->calculateContext($entity)
+    );
+  }
+
+  /**
+   * Calculate the context for the serialize/normalize operation.
+   *
+   * @param \Drupal\Core\Entity\EntityInterface $entity
+   *   The entity to generate the JSON from.
+   *
+   * @return array
+   *   The context.
+   */
+  protected function calculateContext(EntityInterface $entity) {
+    // TODO: Supporting includes requires adding the 'include' query string.
+    $request = new Request();
+    return [
+      'account' => $this->currentUser,
+      'cacheable_metadata' => new CacheableMetadata(),
+      'resource_type' => $this->resourceTypeRepository->get(
+        $entity->getEntityTypeId(),
+        $entity->bundle()
+      ),
+      'request' => $request,
+    ];
+  }
+
+}
diff --git a/src/Normalizer/JsonApiDocumentTopLevelNormalizer.php b/src/Normalizer/JsonApiDocumentTopLevelNormalizer.php
index 8adbf12..6eb6179 100644
--- a/src/Normalizer/JsonApiDocumentTopLevelNormalizer.php
+++ b/src/Normalizer/JsonApiDocumentTopLevelNormalizer.php
@@ -130,7 +130,9 @@ class JsonApiDocumentTopLevelNormalizer extends NormalizerBase implements Denorm
    * {@inheritdoc}
    */
   public function normalize($object, $format = NULL, array $context = array()) {
-    $context += ['resource_type' => $this->currentContext->getResourceType()];
+    if (empty($context['resource_type'])) {
+      $context['resource_type'] = $this->currentContext->getResourceType();
+    }
     $value_extractor = $this->buildNormalizerValue($object->getData(), $format, $context);
     if (!empty($context['cacheable_metadata'])) {
       $context['cacheable_metadata']->addCacheableDependency($value_extractor);
diff --git a/tests/src/Kernel/EntityToJsonApiTest.php b/tests/src/Kernel/EntityToJsonApiTest.php
new file mode 100644
index 0000000..b08accb
--- /dev/null
+++ b/tests/src/Kernel/EntityToJsonApiTest.php
@@ -0,0 +1,200 @@
+<?php
+
+namespace Drupal\Tests\jsonapi\Kernel;
+
+use Drupal\Component\Serialization\Json;
+use Drupal\Core\Field\FieldStorageDefinitionInterface;
+use Drupal\file\Entity\File;
+use Drupal\jsonapi\EntityToJsonApi;
+use Drupal\jsonapi\LinkManager\LinkManager;
+use Drupal\node\Entity\Node;
+use Drupal\node\Entity\NodeType;
+use Drupal\taxonomy\Entity\Term;
+use Drupal\taxonomy\Entity\Vocabulary;
+use Drupal\Tests\image\Kernel\ImageFieldCreationTrait;
+use Drupal\user\Entity\Role;
+use Drupal\user\Entity\User;
+use Drupal\user\RoleInterface;
+use Prophecy\Argument;
+
+/**
+ * @coversDefaultClass \Drupal\jsonapi\EntityToJsonApi
+ * @group jsonapi
+ * @group jsonapi_serializer
+ */
+class EntityToJsonApiTest extends JsonapiKernelTestBase {
+
+  use ImageFieldCreationTrait;
+
+  /**
+   * System under test.
+   *
+   * @var \Drupal\jsonapi\EntityToJsonApi
+   */
+  protected $sut;
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = [
+    'jsonapi',
+    'field',
+    'node',
+    'serialization',
+    'system',
+    'taxonomy',
+    'text',
+    'user',
+    'file',
+    'image',
+  ];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp() {
+    parent::setUp();
+    // Add the entity schemas.
+    $this->installEntitySchema('node');
+    $this->installEntitySchema('user');
+    $this->installEntitySchema('taxonomy_term');
+    $this->installEntitySchema('file');
+    // Add the additional table schemas.
+    $this->installSchema('system', ['sequences']);
+    $this->installSchema('node', ['node_access']);
+    $this->installSchema('user', ['users_data']);
+    $this->installSchema('file', ['file_usage']);
+    $this->nodeType = NodeType::create([
+      'type' => 'article',
+    ]);
+    $this->nodeType->save();
+    $this->createEntityReferenceField(
+      'node',
+      'article',
+      'field_tags',
+      'Tags',
+      'taxonomy_term',
+      'default',
+      ['target_bundles' => ['tags']],
+      FieldStorageDefinitionInterface::CARDINALITY_UNLIMITED
+    );
+
+    $this->createImageField('field_image', 'article');
+
+    $this->user = User::create([
+      'name' => 'user1',
+      'mail' => 'user@localhost',
+    ]);
+    $this->user2 = User::create([
+      'name' => 'user2',
+      'mail' => 'user2@localhost',
+    ]);
+
+    $this->user->save();
+    $this->user2->save();
+
+    $this->vocabulary = Vocabulary::create(['name' => 'Tags', 'vid' => 'tags']);
+    $this->vocabulary->save();
+
+    $this->term1 = Term::create([
+      'name' => 'term1',
+      'vid' => $this->vocabulary->id(),
+    ]);
+    $this->term2 = Term::create([
+      'name' => 'term2',
+      'vid' => $this->vocabulary->id(),
+    ]);
+
+    $this->term1->save();
+    $this->term2->save();
+
+    $this->file = File::create([
+      'uri' => 'public://example.png',
+      'filename' => 'example.png',
+    ]);
+    $this->file->save();
+
+    $this->node = Node::create([
+      'title' => 'dummy_title',
+      'type' => 'article',
+      'uid' => 1,
+      'field_tags' => [
+        ['target_id' => $this->term1->id()],
+        ['target_id' => $this->term2->id()],
+      ],
+      'field_image' => [
+        [
+          'target_id' => $this->file->id(),
+          'alt' => 'test alt',
+          'title' => 'test title',
+          'width' => 10,
+          'height' => 11,
+        ],
+      ],
+    ]);
+
+    $this->node->save();
+
+    $link_manager = $this->prophesize(LinkManager::class);
+    $link_manager
+      ->getEntityLink(Argument::any(), Argument::any(), Argument::type('array'), Argument::type('string'))
+      ->willReturn('dummy_entity_link');
+    $link_manager
+      ->getRequestLink(Argument::any())
+      ->willReturn('dummy_document_link');
+    $this->container->set('jsonapi.link_manager', $link_manager->reveal());
+
+    $this->nodeType = NodeType::load('article');
+
+    $this->role = Role::create([
+      'id' => RoleInterface::ANONYMOUS_ID,
+      'permissions' => [
+        'access content',
+      ],
+    ]);
+    $this->role->save();
+    $this->sut = \Drupal::service('jsonapi.entity.to_jsonapi');
+  }
+
+  /**
+   * @covers ::serialize
+   * @covers ::normalize
+   */
+  public function testSerialize() {
+    $entities = [
+      $this->node,
+      $this->user,
+      $this->file,
+      $this->term1,
+      // Make sure we also support configuration entities.
+      $this->vocabulary,
+      $this->nodeType,
+      $this->role,
+    ];
+    array_walk(
+      $entities,
+      function ($entity) {
+        $output = $this->sut->serialize($entity);
+        $this->assertInternalType('string', $output);
+        $this->assertJsonApi(Json::decode($output));
+        $output = $this->sut->normalize($entity);
+        $this->assertInternalType('array', $output);
+        $this->assertJsonApi($output);
+      }
+    );
+  }
+
+  /**
+   * Helper to assert if a string is valid JSON API.
+   *
+   * @param array $structured
+   *   The JSON API data to check.
+   */
+  protected function assertJsonApi(array $structured) {
+    $this->assertNotEmpty($structured['data']['type']);
+    $this->assertNotEmpty($structured['data']['id']);
+    $this->assertNotEmpty($structured['data']['attributes']);
+    $this->assertInternalType('string', $structured['links']['self']);
+  }
+
+}