JSON to Swift Struct Converter
Convert JSON objects to Swift struct definitions with Codable protocol support. Perfect for iOS, macOS, and server-side Swift development with automatic JSON encoding/decoding.
Conversion Options
Recommended Settings
Swift Struct Best Practices
- •Use let for immutable properties (recommended for most cases)
- •Always conform to Codable for automatic JSON encoding/decoding
- •Use camelCase for property names following Swift conventions
- •Generate CodingKeys to map snake_case JSON to camelCase Swift
- •Make structs internal by default, public only when needed
Type Selection Guide
- •String: Use for text data, emoji-safe and Unicode-compliant
- •Int: Sufficient for most integers, 64-bit on modern devices
- •Double: Preferred over Float for decimal precision
- •Bool: Use for true/false values, not integers
- •Optional (?): Use for nullable fields, safer than force unwrap (!)
Pro Tips
- •Codable is built into Swift's Foundation framework - no external dependencies
- •CodingKeys automatically maps JSON keys to Swift property names
- •Use JSONDecoder() to parse JSON into your structs
- •Add Equatable to enable == comparisons between struct instances
Most Popular
let properties with internal access and CodingKeys for JSON APIs
When to Use This Tool
Create type-safe models for iOS apps consuming REST APIs. Codable provides automatic JSON parsing with compile-time type checking, eliminating runtime parsing errors.
Build data models for SwiftUI views with automatic ObservableObject integration. Structs provide value semantics perfect for SwiftUI's data flow patterns.
Define request/response models for Vapor or Kitura server applications. Codable works seamlessly on both client and server for consistent data structures.
Map JSON API responses to Core Data entities or local storage models. Provides a bridge between network data and persistent storage layers.
Generate mock data structures from API response samples for comprehensive unit tests. Ensures test data matches production API structure exactly.
Share data models across iOS, macOS, watchOS, and tvOS applications. Single struct definition works across all Apple platforms with Codable.
How It Works
Parse and validate JSON input
Detect property types and nested objects
Convert field names to camelCase
Generate nested struct definitions
Create CodingKeys enum for mapping
Format output with proper Swift syntax
100% Private
Files never leave your device. All processing happens locally in your browser.
Lightning Fast
Powered by Pure JavaScript for optimal performance on modern browsers.
Secure
No data collection, no tracking, no sign-up required.
Frequently Asked Questions
What is Codable and why do I need it?
Codable is a Swift protocol (actually Encodable + Decodable) that enables automatic conversion between Swift types and external representations like JSON. With Codable, JSONDecoder can automatically parse JSON into your struct, and JSONEncoder can convert it back. It's type-safe, built-in, and eliminates manual parsing code.
Should I use let or var for properties?
Use let (immutable) by default for value types like structs. This prevents accidental mutations, is thread-safe, and follows Swift best practices. Use var only for properties that genuinely need to change after initialization, like UI state or mutable data models.
What does the CodingKeys enum do?
CodingKeys maps JSON keys to Swift property names. It's essential when JSON uses snake_case (user_name) but Swift uses camelCase (userName). The enum tells the decoder/encoder which JSON key corresponds to each Swift property. Without it, property names must match JSON keys exactly.
When should I use public vs internal access control?
Use internal (default) for structs used only within your module/app. Use public for structs in frameworks, libraries, or shared modules that other modules will import. Use private sparingly for nested types that should be completely hidden.
How do I handle optional/nullable fields?
Swift uses Optional types (?) for nullable values. If a JSON field can be null or missing, make the property optional: var email: String?. Codable automatically handles nil values. Access optionals with optional chaining (user?.email) or if-let unwrapping for safety.
What's the difference between Equatable and Hashable?
Equatable enables comparing structs with == and !=. Hashable (which includes Equatable) enables using structs as dictionary keys or in Sets. Swift can auto-generate both if all properties are themselves Equatable/Hashable. Add them when you need to compare or store structs in collections.
How do I actually use the generated Swift code?
Import the struct into your Swift project. Use JSONDecoder: let decoder = JSONDecoder(); let user = try decoder.decode(User.self, from: jsonData). For encoding back: let encoder = JSONEncoder(); let jsonData = try encoder.encode(user). Handle errors with do-catch blocks.
Can this handle nested JSON objects?
Yes! The tool automatically generates separate struct definitions for nested objects. Nested structs are defined before their parent structs to satisfy Swift's type dependencies. Each nested object becomes its own Codable struct with full type safety.