So, your application retrieves data from a REST API and you need to decode it into custom objects and save them to CoreData, but you aren't sure how to do it.
I was recently in this position while building a bookmarks and rss feed manager.
While researching how to handle this, I came across multiple options, like creating a model that maps the JSON response and a separate one that is the actual CoreData entity to save and use throughout the app. But this seemed too much work to me, but it can suits other scenarios.
Then I saw this method that is exactly was I was looking for, quick and easy, with no model duplicates.
## Steps
1. Run a `request` to the endpoint you want to fetch the data from
2. Decode the `Data` you received and save the `context`
Done!
 
As you can see these are not a lot of steps. In this article I will explain only the second one.
So, with no further ado let's begin.
## Setup
First, we are going to create a couple of helpers that will make our life easier.
The first one is a custom error that we will throw in case the `context` is not present.
```swift
enum DecoderConfigurationError: Error {
  case missingManagedObjectContext
}
```
The second one is a `CodingUserInfoKey` that we will use to assign and retrieve the `context`.
```swift
extension CodingUserInfoKey {
  static let managedObjectContext = CodingUserInfoKey(rawValue: "managedObjectContext")!
}
```
## Decoding
Once we have those out of the way, we can start decoding our data.
We will use the default `JSONDecoder` and we will use the `userInfo` property to assign our `NSManagedObjectContext` to the `CodingUserInfoKey.managedObjectContext` key.
This way we are passing the `context` that we will use to create the `NSManagedObject` to the `init(from:) `.
```swift
do {
  let decoder = JSONDecoder()
  decoder.userInfo[.managedObjectContext] = PersistenceController.shared.context
 
  let decodedObject = try decoder.decode(Object.self, from: data)
} catch {
  // [Handle error...]
}
```
!NOTE The `PersistenceController` class is the implementation of the CoreData stack. You can find an example [here](/articles/persistence-controller).
## Conforming to Decodable
Now we can make our `NSManagedObject` conform to `decodable`.
```swift
class Object: NSManagedObject, Decodable {
  // [...]
}
```
Once we have done that we implement the `init(from:)` initialiser.
```swift
class Object: NSManagedObject, Decodable {
 
  private enum CodingKeys: String, CodingKey {
      case objectProperty
      // [...]
  }
 
  required convenience init(from decoder: Decoder) throws {
 
    // 1. Retrieve the context
    guard let context = decoder.userInfo[CodingUserInfoKey.managedObjectContext] as? NSManagedObjectContext else {
 
      // 2. Throw an error in case the context is not present
      throw DecoderConfigurationError.missingManagedObjectContext
    }
 
    // 3. Instantiate the CoreData entity
    self.init(context: context)
 
    // 4. Decode the object properties
    let container = try decoder.container(keyedBy: CodingKeys.self)
    self.objectProperty = try container.decode(String.self, forKey: . objectProperty)
    // [Continue decoding properties...]
  }
}
```
In the code above we set up the decoding method:
1. We retrieve the `NSManagedObjectContext` that we passed earlier using the `userInfo` property.
2. We throw an error in case the context is not present
3. We instantiate the CoreData entity using the `context` we retrieved
4. And we decode each property from the data we received from the API
## Save the context
Finally we save the `context` to persist our decoded objects.
```swift
context.save()
```
## Conclusion
In this way we can decode and persist our data in one single step. With no need to create a separate model that handles the decoding process.
I found this method really effective in my experience, I hope it will be useful to you as well.
If you have any doubt or question leave a comment and I'll be glad to reply.

See how to convert fetched data from a REST API to entities and persist them to CoreData, the built-in local database of Apple.

REST API

From REST API to CoreData in One Step