What Ruby frameworks are supported?

This tool supports four modes: Plain Ruby (attr_accessor with initialize, from_json, to_json), Struct (Ruby Struct class generation), ActiveModel (includes ActiveModel::Serialization and ActiveModel::Validations), and Dry-Struct (uses dry-struct gem with Types module for type-safe attributes).

Is my data sent to a server?

No, all processing happens entirely in your browser. Your JSON data never leaves your device.

JSON to Ruby Class Generator Online

Symbolize KeysRequire JSON

JSON Input

Ruby Output (.rb)

What is JSON to Ruby Class Generator?

Ruby is a dynamic, object-oriented language where everything is an object, and its elegant syntax makes it a popular choice for web development, scripting, and API design. This generator transforms your JSON data into idiomatic Ruby class definitions with full serialization support. It offers four distinct output modes tailored to different Ruby ecosystems: Plain Ruby classes with attr_accessor and manual from_json/to_json methods, Ruby Struct for lightweight value objects, ActiveModel classes with validations and serialization for Rails applications, and Dry-Struct classes for immutable, type-safe value objects using the dry-rb ecosystem. Each mode generates complete, ready-to-use code including constructors, serialization methods, and proper type annotations inferred from your JSON values.

How to Use

Enter a root class name in the input field — this becomes the name of the top-level Ruby class
Select a framework mode: Plain Ruby, Struct, ActiveModel, or Dry-Struct depending on your project needs
Toggle Symbolize Keys to use Ruby symbols instead of string keys in JSON parsing
Toggle Require JSON to include the require "json" header in the output
Paste your JSON data into the input area and click "Generate Ruby Code"
Copy the generated classes into your Ruby project and customize as needed

Why Use This Tool?

Automatic type inference maps JSON values to their correct Ruby types — String, Integer, Float, TrueClass, Array, and NilClass

Complete from_json and to_json (or to_hash) methods are generated for every class, enabling round-trip serialization without extra gems

ActiveModel mode produces Rails-ready classes with presence validations and serializable_hash for API integration

Dry-Struct mode creates immutable, type-safe value objects using the Types module for strict type checking at instantiation

Nested JSON objects are extracted into separate Ruby classes with proper cross-references and recursive serialization

Symbolize Keys option lets you choose between string and symbol keys to match your project conventions

Tips & Best Practices

Provide JSON with representative values — the Ruby type for each field is inferred from actual data, so null fields default to NilClass
ActiveModel mode adds presence validations for every non-nil field, which is useful for form objects and API payloads in Rails
Dry-Struct mode requires the dry-struct gem and produces immutable objects — ideal for value objects and configuration data that should not change after creation
Enable Symbolize Keys when your application uses symbol-based hash access (e.g., data[:name]) instead of string-based access (e.g., data["name"])
The Require JSON toggle adds the standard library import — disable it if your project already loads JSON through Bundler or another require mechanism

Frequently Asked Questions

How are JSON types mapped to Ruby types?

JSON strings map to String, integers map to Integer, decimal numbers map to Float, booleans map to TrueClass, null maps to NilClass (marked as nullable), arrays map to Array, and nested objects become separate Ruby classes. In Dry-Struct mode, the Types module is used: Types::String, Types::Integer, Types::Float, Types::Bool, Types::Nil, and nullable fields use Types::Nil | Types::String.

When should I NOT use this generator?

Skip this tool if you need custom Ruby logic like computed attributes, callbacks, or associations that go beyond simple data containers. Also, if your JSON uses polymorphic structures (e.g., a field that is sometimes an object and sometimes an array), the generated code will not handle that correctly without manual modifications.

What is ActiveModel mode?

ActiveModel mode generates classes that include ActiveModel::Serialization and ActiveModel::Validations. It provides attr_accessor for all fields, an initialize method that accepts keyword arguments, and presence validations for non-nil fields. The serializable_hash method handles serialization, making it compatible with Rails controllers and Jbuilder templates.

What is Dry-Struct mode?

Dry-Struct mode generates classes that inherit from Dry::Struct with attributes defined using the Types module (e.g., attribute :name, Types::String). Dry-Struct provides immutable, type-safe objects with built-in validation and coercion at instantiation time. It requires the dry-struct gem and is ideal for applications that value functional programming patterns.

How are nested objects handled?

Nested JSON objects are converted to separate Ruby classes with their own definitions. They are ordered children-first so that referenced classes are defined before the parent class. The parent class calls the nested class from_json_hash and to_hash methods for recursive serialization.

Is my data sent to any external server?

No. All processing happens entirely inside your browser. Your JSON data never leaves your device, and no network requests are made during the conversion.

Real-world Examples

Generating an ActiveModel user class for a Rails API

Create a validated ActiveModel class from a JSON payload for use in a Rails API controller.

Input

{
  "name": "Alice",
  "email": "alice@example.com",
  "age": 30,
  "role": "admin"
}

Output

class User
  include ActiveModel::Serialization
  include ActiveModel::Validations

  attr_accessor :name, :email, :age, :role

  validates :name, presence: true
  validates :email, presence: true
  validates :age, presence: true
  validates :role, presence: true

  def initialize(name:, email:, age:, role:)
    @name = name
    @email = email
    @age = age
    @role = role
  end
  ...
end

Dry-Struct value objects for a configuration model

Generate immutable Dry-Struct classes from a nested JSON configuration object.