diff --git a/core/modules/rest/src/Plugin/Deriver/EntityDeriver.php b/core/modules/rest/src/Plugin/Deriver/EntityDeriver.php
index 6a6ddae..488b3f3 100644
--- a/core/modules/rest/src/Plugin/Deriver/EntityDeriver.php
+++ b/core/modules/rest/src/Plugin/Deriver/EntityDeriver.php
@@ -2,8 +2,10 @@
 
 namespace Drupal\rest\Plugin\Deriver;
 
+use Drupal\Core\Config\Entity\ConfigEntityTypeInterface;
 use Drupal\Core\Entity\EntityManagerInterface;
 use Drupal\Core\Plugin\Discovery\ContainerDeriverInterface;
+use Drupal\rest\Plugin\rest\resource\ConfigEntityResource;
 use Symfony\Component\DependencyInjection\ContainerInterface;
 
 /**
@@ -88,6 +90,10 @@ public function getDerivativeDefinitions($base_plugin_definition) {
           }
         }
 
+        if ($entity_type instanceof ConfigEntityTypeInterface) {
+          $this->derivatives[$entity_type_id]['class'] = ConfigEntityResource::class;
+        }
+
         $this->derivatives[$entity_type_id] += $base_plugin_definition;
       }
     }
diff --git a/core/modules/rest/src/Plugin/rest/resource/ConfigEntityResource.php b/core/modules/rest/src/Plugin/rest/resource/ConfigEntityResource.php
new file mode 100644
index 0000000..c593bd2
--- /dev/null
+++ b/core/modules/rest/src/Plugin/rest/resource/ConfigEntityResource.php
@@ -0,0 +1,24 @@
+<?php
+
+namespace Drupal\rest\Plugin\rest\resource;
+
+use Drupal\Core\Entity\EntityConstraintViolationList;
+use Drupal\Core\Entity\EntityInterface;
+
+/**
+ * Specific config entity resource with special behaviour for validation.
+ */
+class ConfigEntityResource extends EntityResource {
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function validate(EntityInterface $entity) {
+    // Add a custom config entity resource class in order to provide
+    /** @var \Drupal\Core\Config\Entity\ConfigEntityInterface $entity */
+    $typed_config = $entity->getTypedData();
+    $violations = $typed_config->validate();
+    return new EntityConstraintViolationList($entity, iterator_to_array($violations));
+  }
+
+}
diff --git a/core/modules/rest/src/Plugin/rest/resource/EntityResource.php b/core/modules/rest/src/Plugin/rest/resource/EntityResource.php
index 7e620df..997a62b 100644
--- a/core/modules/rest/src/Plugin/rest/resource/EntityResource.php
+++ b/core/modules/rest/src/Plugin/rest/resource/EntityResource.php
@@ -147,9 +147,11 @@ public function post(EntityInterface $entity = NULL) {
     // Only check 'edit' permissions for fields that were actually
     // submitted by the user. Field access makes no difference between 'create'
     // and 'update', so the 'edit' operation is used here.
-    foreach ($entity->_restSubmittedFields as $key => $field_name) {
-      if (!$entity->get($field_name)->access('edit')) {
-        throw new AccessDeniedHttpException("Access denied on creating field '$field_name'");
+    if ($entity instanceof FieldableEntityInterface) {
+      foreach ($entity->_restSubmittedFields as $key => $field_name) {
+        if (!$entity->get($field_name)->access('edit')) {
+          throw new AccessDeniedHttpException("Access denied on creating field '$field_name'");
+        }
       }
     }
 
diff --git a/core/modules/rest/src/Tests/CreateTest.php b/core/modules/rest/src/Tests/CreateTest.php
index 28c8af6..0d8b600 100644
--- a/core/modules/rest/src/Tests/CreateTest.php
+++ b/core/modules/rest/src/Tests/CreateTest.php
@@ -4,6 +4,8 @@
 
 use Drupal\comment\Tests\CommentTestTrait;
 use Drupal\Component\Serialization\Json;
+use Drupal\Core\Config\Entity\ConfigEntityInterface;
+use Drupal\Core\Config\Entity\ConfigEntityTypeInterface;
 use Drupal\Core\Entity\EntityInterface;
 use Drupal\entity_test\Entity\EntityTest;
 use Drupal\node\Entity\Node;
@@ -319,6 +321,38 @@ public function testCreateUser() {
   }
 
   /**
+   * Tests the creation of config entities.
+   */
+  public function testCreateConfigEntity() {
+    \Drupal::service('module_installer')->install(['config_test']);
+    $this->rebuildContainer();
+
+    $entity_type = 'config_test';
+    // Enables the REST service for 'user' entity type.
+    $this->enableService('entity:' . $entity_type, 'POST');
+    // Create two accounts that have the required permissions to create
+    // resources. The second one has administrative permissions.
+    $accounts = $this->createAccountPerEntity($entity_type);
+
+    // Verify create requests per user.
+    foreach ($accounts as $key => $account) {
+      $this->drupalLogin($account);
+      // Populate some entity properties before create the entity.
+      $entity_values = $this->entityValues($entity_type);
+      $entity = \Drupal::entityTypeManager()->getStorage('config_test')->create($entity_values);
+
+      // Serialize the entity before the POST request.
+      $serialized = $this->serializer->serialize($entity, $this->defaultFormat, ['account' => $account]);
+
+      // Create the entity over the REST API.
+      $this->assertCreateEntityOverRestApi($entity_type, $serialized);
+      // Get the entity ID from the location header and try to read it from the
+      // database.
+      $this->assertReadEntityIdFromHeaderAndDb($entity_type, $entity, $entity_values);
+    }
+  }
+
+  /**
    * Creates user accounts that have the required permissions to create
    * resources via the REST API. The second one has administrative permissions.
    *
@@ -348,22 +382,29 @@ public function createAccountPerEntity($entity_type) {
   /**
    * Creates the entity over the REST API.
    *
-   * @param string $entity_type
+   * @param string $entity_type_id
    *   The type of the entity that should be created.
    * @param string $serialized
    *   The body for the POST request.
    */
-  public function assertCreateEntityOverRestApi($entity_type, $serialized = NULL) {
+  public function assertCreateEntityOverRestApi($entity_type_id, $serialized = NULL) {
+    $entity_type = \Drupal::entityTypeManager()->getDefinition($entity_type_id);
     // Note: this will fail with PHP 5.6 when always_populate_raw_post_data is
     // set to something other than -1. See https://www.drupal.org/node/2456025.
-    $response = $this->httpRequest('entity/' . $entity_type, 'POST', $serialized, $this->defaultMimeType);
+    $response = $this->httpRequest('entity/' . $entity_type_id, 'POST', $serialized, $this->defaultMimeType);
     $this->assertResponse(201);
 
     // Make sure that the response includes an entity in the body and check the
     // UUID as an example.
     $request = Json::decode($serialized);
     $response = Json::decode($response);
-    $this->assertEqual($request['uuid'][0]['value'], $response['uuid'][0]['value'], 'Got new entity created as response after successful POST over Rest API');
+
+    if ($entity_type instanceof ConfigEntityTypeInterface) {
+      $this->assertEqual($request['uuid'], $response['uuid'], 'Got new entity created as response after successful POST over Rest API');
+    }
+    else {
+      $this->assertEqual($request['uuid'][0]['value'], $response['uuid'][0]['value'], 'Got new entity created as response after successful POST over Rest API');
+    }
   }
 
   /**
@@ -389,9 +430,16 @@ public function assertReadEntityIdFromHeaderAndDb($entity_type, EntityInterface
     $this->assertEqual($entity->uuid(), $loaded_entity->uuid(), 'UUID of created entity is correct.');
 
     // Verify that the field values sent and received from DB are the same.
+
     foreach ($entity_values as $property => $value) {
-      $actual_value = $loaded_entity->get($property)->value;
-      $send_value = $entity->get($property)->value;
+      if ($loaded_entity instanceof ConfigEntityInterface) {
+        $actual_value = $loaded_entity->get($property);
+        $send_value = $entity->get($property);
+      }
+      else {
+        $actual_value = $loaded_entity->get($property)->value;
+        $send_value = $entity->get($property)->value;
+      }
       $this->assertEqual($send_value, $actual_value, 'Created property ' . $property . ' expected: ' . $send_value . ', actual: ' . $actual_value);
     }