JSON to Haskell

Generate Haskell data types and Aeson instances from JSON samples

All processing happens in your browser. No data is sent to any server.

JSON Input

Haskell Output

{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE DeriveGeneric #-}

module Types where

import Data.Aeson
import Data.Text (Text)
import GHC.Generics (Generic)

data Address = Address
  { addressStreet :: Text
  , addressCity :: Text
  , addressZip :: Text
  } deriving (Show, Eq, Generic)

instance FromJSON Address where
  parseJSON = withObject "Address" $ \v -> Address
    <$> v .: "street"
    <*> v .: "city"
    <*> v .: "zip"

instance ToJSON Address where
  toJSON x = object
    [ "street" .= addressStreet x
    , "city" .= addressCity x
    , "zip" .= addressZip x
    ]

data User = User
  { userId :: Int
  , userName :: Text
  , userEmail :: Text
  , userIsActive :: Bool
  , userScore :: Double
  , userTags :: [Text]
  , userAddress :: Address
  , userNotes :: Maybe Text
  } deriving (Show, Eq, Generic)

instance FromJSON User where
  parseJSON = withObject "User" $ \v -> User
    <$> v .: "id"
    <*> v .: "name"
    <*> v .: "email"
    <*> v .: "isActive"
    <*> v .: "score"
    <*> v .: "tags"
    <*> v .: "address"
    <*> v .:? "notes"

instance ToJSON User where
  toJSON x = object
    [ "id" .= userId x
    , "name" .= userName x
    , "email" .= userEmail x
    , "isActive" .= userIsActive x
    , "score" .= userScore x
    , "tags" .= userTags x
    , "address" .= userAddress x
    , "notes" .= userNotes x
    ]

data Root = Root
  { rootUser :: User
  } deriving (Show, Eq, Generic)

instance FromJSON Root where
  parseJSON = withObject "Root" $ \v -> Root
    <$> v .: "user"

instance ToJSON Root where
  toJSON x = object
    [ "user" .= rootUser x
    ]

Generated types use Data.Aeson for JSON serialization. Add aeson and text to your Cabal/Stack dependencies.

Why This Tool

Writing Haskell data types and JSON parsing instances by hand is tedious and error-prone. This tool analyzes a JSON sample and generates the corresponding Haskell types with Aeson FromJSON/ToJSON instances.

How It Works

Paste a JSON sample into the editor. The tool infers the structure, generates Haskell data types with appropriate field types, and adds Aeson instances for JSON serialization and deserialization.

Related Tools

More JSON Tools

JSON Formatter JSON Viewer & Tree Explorer JSON Diff Tool JSON Merge Tool JSON Path Evaluator JSON Schema Validator View all →