İçerik yok
Free online JSON to Swift tool. Convert API responses, configuration files, or log JSON into pure Swift struct/class type declarations in one click. No registration, no upload. Real-time generation locally in your browser. Ideal for rapid modeling in iOS, macOS, watchOS, and tvOS projects.
JSON to Swift is the process of automatically converting JSON-formatted data (objects or arrays) into Swift struct/class type declarations. JSON is the de facto standard for REST APIs, configuration files, and event logs, while Swift is the primary development language for iOS, macOS, watchOS, and tvOS apps, and also a core language for server frameworks like Vapor. Developers frequently need to write corresponding Swift types for API-returned JSON; writing by hand is not only time-consuming but also prone to missing optional fields. The purpose of this tool is to automate this process.
This tool uses quicktype-core to complete conversion locally in the browser. quicktype is a multilingual structure generator; this tool enables just-types and no-comments options for Swift, so output is clean struct/class property declarations without serialization annotations like Codable, Decodable, Encodable, and without import statements or file header comments. These "bare types" make it easy for developers to freely add protocols, adjust access control, or change naming conventions preferred by network frameworks like Alamofire/Moya per project needs.
Swift's type system is known for safety. struct is a value type suitable for representing immutable data; class is a reference type suitable for scenarios requiring shared state or inheritance. Properties generated by this tool are mapped to Swift's String, Int, Double, Bool, [T], custom types, etc., as much as possible. After generation, developers can change certain fields to Optional (?), add Codable protocols to types, or upgrade entire structs to classes to get reference semantics per business needs.
Nested object handling is a key capability of the tool. When JSON contains nested objects, the tool recursively generates independent subtypes; for example, if Root contains an address object, an Address type is generated and referenced in the main type via var address: Address. This avoids duplicate type definitions and allows Xcode's autocompletion and type checking to correctly track hierarchical relationships. The naming rule capitalizes the first letter of field names; for example, elements in a users array are named User.
Array type inference follows a "infer from first element" strategy. If array elements are strings, [String] is generated; if integers, [Int]; if floating-point, [Double]; if objects, [CustomType]. Empty arrays [] lack samples and generate [Any] or fallback types; it's recommended to change to concrete types after generation based on actual business. For particularly large or sparse arrays, it's recommended to put real sample elements in the source JSON to improve inference accuracy.
Pure frontend processing is the core architectural advantage of this tool. All JSON parsing and Swift code generation are executed in browser JavaScript (including quicktype-core in Web Worker), not relying on backend services or sending data to any server. This design both protects JSON data that may contain sensitive information and ensures conversion speed is limited only by local device performance without waiting for network roundtrips. It's especially important for processing JSON containing API keys and unreleased business fields.
Unlike some online tools that force-bind Codable/CodingKeys/Date decoding strategies: team members often have different preferences for protocols, naming, and access control. This tool adheres to the minimal output principle, leaving protocol and strategy choices to developers for further processing per project needs. This "generate semi-finished product + project-level secondary processing" workflow is generally more popular with engineers in mid-to-large teams than "one-click all-inclusive."
Most common usage in iOS/macOS projects: add Codable to structs generated by this tool, then fetch asynchronously with URLSession and decode with JSONDecoder.
import Foundation
// 1) Root type generated by this tool (with Codable protocol added)
struct User: Codable {
let id: Int
let name: String
let email: String
let isActive: Bool
let tags: [String]
}
// 2) URLSession async fetch and decode
func fetchUser(id: Int) async throws -> User {
let url = URL(string: "https://api.example.com/users/\(id)")!
let (data, response) = try await URLSession.shared.data(from: url)
guard
let http = response as? HTTPURLResponse,
(200..<300).contains(http.statusCode)
else {
throw URLError(.badServerResponse)
}
return try JSONDecoder().decode(User.self, from: data)
}
// 3) Usage example (Swift 5.5+ async/await)
Task {
do {
let user = try await fetchUser(id: 42)
print("User: \(user.name), tags: \(user.tags)")
} catch {
print("Failed to decode:", error)
}
}When using Alamofire, you can directly use responseDecodable to automatically decode structs generated by this tool into Swift objects.
import Foundation
import Alamofire
// Type generated by this tool, directly usable after adding Codable
struct Product: Codable {
let id: Int
let title: String
let price: Double
let inStock: Bool
let images: [String]
}
final class ProductService {
private let session: Session
init(session: Session = .default) {
self.session = session
}
/// Alamofire 5 async/await style responseDecodable
func loadProduct(id: Int) async throws -> Product {
let url = "https://api.example.com/products/\(id)"
return try await withCheckedThrowingContinuation { continuation in
session.request(url)
.validate(statusCode: 200..<300)
.responseDecodable(of: Product.self) { response in
switch response.result {
case .success(let product):
continuation.resume(returning: product)
case .failure(let error):
continuation.resume(throwing: error)
}
}
}
}
}
// Moya-style call example
// provider.request(.product(id: 1)).map(Product.self)
// let product: Product = try await provider.request(.product(id: 1)).map(Product.self)In SwiftUI/Combine projects, generated structs can be used with dataTaskPublisher/decode for reactive data streams.
import Foundation
import Combine
// Root type generated by this tool
struct Article: Codable, Identifiable {
let id: Int
let title: String
let body: String
let publishedAt: Date
}
final class ArticleRepository {
private let session: URLSession
private var cancellables = Set<AnyCancellable>()
init(session: URLSession = .shared) {
self.session = session
}
/// Expose data stream with Combine
func articlePublisher(id: Int) -> AnyPublisher<Article, Error> {
let url = URL(string: "https://api.example.com/articles/\(id)")!
let decoder = JSONDecoder()
decoder.dateDecodingStrategy = .iso8601
return session.dataTaskPublisher(for: url)
.map(\.data)
.decode(type: Article.self, decoder: decoder)
.receive(on: DispatchQueue.main)
.eraseToAnyPublisher()
}
/// Subscribe in SwiftUI ViewModel
func bind(to viewModel: ArticleViewModel, articleId: Int) {
articlePublisher(id: articleId)
.sink(
receiveCompletion: { completion in
if case .failure(let err) = completion {
viewModel.errorMessage = err.localizedDescription
}
},
receiveValue: { article in
viewModel.article = article
}
)
.store(in: &cancellables)
}
}
final class ArticleViewModel: ObservableObject {
@Published var article: Article?
@Published var errorMessage: String?
}Paste JSON content into the left input box. After a 400ms debounce, the tool automatically calls quicktype-core to convert to Swift code and displays the result in real time in the right panel. You can also click the upload button to select a .json/.txt file, or click the sample button to load built-in data. After conversion, copy with one click or download as a .swift file.
Not by default. This tool uses quicktype-core's just-types mode, outputting pure struct/class property declarations without Codable, Decodable, or Encodable annotations, and without import statements. If you need Codable, simply add : Codable after generation (e.g., struct User: Codable {}), or write your own JSONDecoder parsing logic.
All valid JSON is supported: basic types (null, boolean, number, string), one-dimensional or multi-dimensional arrays, and nested objects of any depth. The root input can be a JSON object or JSON array; the tool processes objects first and arrays by inferring from the first element. Unsupported inputs include JavaScript special values (functions, Symbol, undefined) and non-JSON text.
The tool recursively generates independent Swift types for each nested object. Naming rules are based on a combination of parent type name and field name; for example, if Root contains an address field, an Address subtype is generated and referenced in the main type via var address: Address. This avoids duplicate type definitions and allows Xcode's autocompletion and type checking to correctly track hierarchical relationships.
Yes. JSON arrays are automatically converted to Swift [T] form. If array elements are strings, [String] is generated; if integers, [Int]; if floating-point, [Double]; if objects, [CustomType]. Empty arrays [] have no sample elements and default to [Any]; it's recommended to manually change to [String] or [Int] or other concrete types after generation.
null values in JSON cannot have their concrete type inferred; the tool may generate Any or a fallback type. It's recommended to replace null-valued fields in the source JSON with sample values (e.g., "field": "" infers String) or manually change to Optional per business logic (e.g., var phone: String?), which better aligns with the safety semantics of Swift's type system.
Yes. Click the type name button (or settings entry) in the toolbar to modify the root type name (default like Root or inferred from sample data). Subtype names are automatically generated based on the root name and field names, with the naming rule being capitalizing the first letter of field names, e.g., users → User, tags → Tag.
The tool automatically checks JSON validity. On error, it displays a specific error message on the right and provides a "Fix JSON" button. Clicking automatically fixes common errors: extra trailing commas, single quotes replaced with double quotes, missing quote key completion, comment removal, etc. After successful repair, you can continue converting without manually fixing JSON.
Runs entirely in the local browser. All JSON parsing and Swift code generation are done locally via browser JavaScript (including quicktype-core in Web Worker); input JSON data and generated Swift code are not uploaded to any server, nor recorded or cached to the cloud. Sensitive JSON containing API keys, tokens, user privacy fields, and unreleased business structures can be used safely; closing the page clears everything.
Yes. Generated code is standard Swift syntax that can be directly copied into Xcode .swift files or saved via the "Download" button as a .swift file to drag into projects. Since output is pure type declarations, it's recommended to manually add protocols like Codable, Equatable, Identifiable per project needs, or adjust access control modifiers (public/internal/private).
Yes. When root input is a JSON array, the tool uses the first element of the array as a template to generate the element type and outputs that element type definition. For example, [{"id":1,"name":"A"}] generates a struct named Item (or a name inferred from fields) whose fields are those of the first element; the main type references it via property items: [Item], avoiding treating arrays directly as root types.
There's no explicit size limit, but browser parsing and rendering of very large JSON will slow down. Recommendations: ① Convert only one business module's JSON at a time; ② Split deep nesting into levels for processing; ③ For JSON over several MB, use the command-line version of quicktype; ④ Splitting the same JSON into multiple submodules for separate conversion can significantly reduce memory usage.
Both convert JSON to type definitions for their respective languages, but with different focuses: JSON to Swift generates struct/class property declarations for iOS/macOS native apps; JSON to TypeScript generates interface/type declarations for frontend type checking. If your project has both an iOS client and Web frontend, it's recommended to generate both Swift and TS versions from the same JSON to ensure type consistency across both ends.
This tool outputs pure types by default without protocols directly. After generation, you just need to append : Codable after the struct/class declaration, e.g., struct User: Codable {}, for JSONDecoder to use. If you want Codable by default, you can fork quicktype-core and modify its Swift renderer, or use Xcode's batch replace feature to add the protocol to all types after generation.
First visit requires internet to fetch tool scripts and quicktype-core resources; afterwards it can run offline from browser cache (in previously visited browsers). Mobile browsers (iOS Safari, Android Chrome) also work normally; the interface has a responsive split-screen design that automatically switches to vertical stacking in portrait mode.
Yes. After generation, each Swift type is an independent struct/class. The tool output is pure text; you can copy individual types into Xcode separately, or use Xcode's Rename refactoring to batch modify types and fields without affecting other types. If you need to regenerate the entire set of types, refresh the page and paste JSON again.
quicktype's support for unions/enums requires additional type hints or GraphQL/JSON Schema input. Inferring enums from JSON samples alone is difficult, so this tool does not generate enums by default. If you need enums, you can manually change the corresponding struct to enum + Codable, or use the JSON to Kotlin/TypeScript tool first to get enum types, then manually migrate to Swift.
Left input box is empty or contains only whitespace. Please paste valid JSON content, or click "Sample" to load an example, or click "Upload" to select a .json/.txt file.
JSON format is invalid. Common causes: ① Trailing comma (e.g., {"a":1,}); ② Using single quotes instead of double quotes; ③ JS object syntax (e.g., {key: value}) instead of JSON (e.g., {"key": "value"}); ④ Contains JavaScript comments. Click the "Fix JSON" button to automatically fix some common errors.
This is expected behavior. This tool uses just-types mode, outputting pure struct/class property declarations. If you need Codable, add : Codable to types after generation (e.g., struct User: Codable {}), or write extension User: Codable {} before calling JSONDecoder.
Empty arrays have no sample elements; the tool generates fallback type [Any]. It's recommended to put at least one sample element in the source JSON (e.g., [1, 2]), delete the sample value after generation, and manually specify concrete types; or directly change to more precise types like [String]/[User] after generation.
JSON null cannot have concrete type inferred; the tool may generate Any or fallback types. It's recommended to replace null in source JSON with representative sample values (e.g., "" or 0), then change that field to Optional (?) or concrete type after generation, e.g., var phone: String?.
You can modify the root type name in the toolbar; subtype names are automatically generated based on root name + field names. If still unsatisfied, use Xcode Rename refactoring to batch modify after generation (right-click → Refactor → Rename); Xcode will synchronously update all references.
Browser rendering of very large JSON and generating many types will slow down. It's recommended to split JSON into multiple independent business modules for separate conversion, or only extract key objects that need modeling for conversion; for JSON over 10MB, we recommend using the command-line version of quicktype.
This means after adding Codable to some fields, you didn't correctly handle Optional/Date/Enum and other types. Common fixes: ① Change all fields that may be null to Optional<T>; ② Custom date strategy JSONDecoder().dateDecodingStrategy = .iso8601; ③ Custom CodingKeys to align JSON keys with Swift property names.
This tool preserves original JSON field names by default, so snake_case fields are generated as-is. If you want to unify to camelCase, you can batch rename with Xcode Rename after generation, or convert field names to camelCase in a custom quicktype renderer, then add CodingKeys mapping to ensure correct JSON decoding.
Swift recommends English ASCII identifiers for field names. If source JSON contains Chinese keys (e.g., {"姓名": "Alice"}), generated var 姓名: String will cause Swift compiler errors in some historical versions. It's recommended to change keys to English in source JSON (e.g., name), which better conforms to Swift coding standards.
This tool generates var public properties by default for easy post-generation customization. If you need let or access control (like private(set)), you can batch modify using Refactor → Add Access Control in Xcode, or replace var with let using sed/text editing tools after generation.
This tool maps ISO 8601 strings to String by default; Swift does not automatically convert to Date. You need to set dateDecodingStrategy in JSONDecoder, e.g., JSONDecoder().dateDecodingStrategy = .iso8601. If the date format is non-standard, you'll also need to manually implement DateFormatter or custom parsing logic.
The tool uses "capitalize first letter of field name" for subtype naming. In deeply nested JSON, nested objects with the same name can cause type conflicts. Solutions: ① Add business prefixes to fields in source JSON; ② Split root JSON into multiple independent modules for separate generation; ③ Use Xcode Rename to batch modify conflicting type names after generation.
This tool generates internal struct by default without explicit public modifier. If your project is split by module and requires cross-module access, you need to batch replace struct with public struct in Xcode, or uniformly add public keyword using sed/awk scripts after generation.
The tool automatically infers corresponding Swift types based on JSON value forms:
| JSON Value Example | Detection Method | Generated Swift Type | Notes |
|---|---|---|---|
null | value === null | Any? or concrete Optional | Cannot infer concrete type; recommend manually changing to Optional<T> after generation |
true / false | typeof value === 'boolean' | Bool | Directly maps to Swift boolean type |
42 | typeof value === 'number' && Number.isInteger(value) | Int | Integers map to Int (32/64-bit determined by platform) |
3.14 | typeof value === 'number' && !Number.isInteger(value) | Double | Floating point numbers map to Double |
"hello" | typeof value === 'string' | String | Strings map to String |
[] (empty array) | Array.isArray(value) && value.length === 0 | [Any] | Cannot infer element type; recommend adding examples or manually changing to concrete types |
["a", "b"] | Array.isArray(value) && typeof value[0] === 'string' | [String] | String array |
[1, 2, 3] | Array.isArray(value) && typeof value[0] === 'number' | [Int] | Integer array |
[1.5, 2.5] | Array.isArray(value) && typeof value[0] === 'number' && !Number.isInteger(value[0]) | [Double] | Float array |
[{...}, {...}] | Array.isArray(value) && typeof value[0] === 'object' | [Item] | Object array, elements are custom types named by field name inference |
{...} (nested object) | typeof value === 'object' && !Array.isArray(value) | Independent struct/class | Recursively generates independent types, named by capitalizing first letter of field names |
Generated Swift types can be directly used in different scenarios on Apple platforms/third-party frameworks:
| Use Case | Common Frameworks | Required Protocols/Processing | Typical Code Snippet |
|---|---|---|---|
REST API parsing | URLSession + JSONDecoder | Add Codable to types, maintain struct value semantics | try JSONDecoder().decode(User.self, from: data) |
Simplified HTTP requests | Alamofire | Add Codable to types, pair with responseDecodable | session.request(url).responseDecodable(of: User.self) |
Abstract network layer | Moya | Add Codable to types, Moya auto-deserializes | provider.request(.user(id: 1)).map(User.self) |
Reactive data streams | Combine + JSONDecoder | Add Codable to types, combine with dataTaskPublisher | URLSession.shared.dataTaskPublisher(for: url).decode(type: User.self, decoder: decoder) |
SwiftUI list display | SwiftUI List + Identifiable | Add Identifiable to types for automatic List forEach | List(items) { Text($0.name) } |
Server model definitions | Vapor | Add Codable to types, Vapor auto Content serialization | struct User: Codable, Content { var id: Int; var name: String } |
Local persistence models | SwiftData/Core Data | Add @Model/@NSManaged to generated struct/class | @Model class User { var id: Int; var name: String } |
Cross-platform type sharing | JSON to Swift + JSON to TypeScript combined | Keep Swift and TS field names consistent, pair TS types on TS end | Swift: var name: String / TS: name: string |
All JSON parsing and Swift type generation operations of this JSON to Swift tool are completed entirely locally in your browser via JavaScript (quicktype-core/Web Worker). Input JSON data and generated Swift code are never uploaded to any server, nor recorded, cached, or stored in the cloud. Sensitive JSON containing internal interface fields, API keys, tokens, user privacy data, and unreleased business structures can be used safely. All input and output content is automatically cleared from memory when closing or refreshing the page, with no dependency on third-party network services.