Nog geen content
Gratis online JSON naar Swift converter. Converteer met één klik API-reacties, configuratiebestanden of log-JSON naar pure Swift struct/class type-declaraties. Geen registratie, geen upload: realtime generatie in uw browser. Perfect voor snelle modellering in iOS-, macOS-, watchOS- en tvOS-projecten.
JSON naar Swift is het proces van het automatisch converteren van JSON-gegevens (objecten of arrays) naar Swift struct/class type-declaraties. JSON is de de facto standaard voor REST API's, configuratiebestanden en analyselogboeken, terwijl Swift de primaire ontwikkeltaal is voor iOS-, macOS-, watchOS- en tvOS-apps, evenals een kerntaal voor server-side frameworks zoals Vapor. Tijdens ontwikkeling is het vaak nodig om de bijbehorende Swift-typen te schrijven voor JSON die door API's wordt geretourneerd; ze handmatig schrijven is tijdrovend en vatbaar voor het weglaten van optionele velden. Het doel van deze tool is om dit proces te automatiseren.
Deze tool gebruikt quicktype-core om conversie lokaal in de browser uit te voeren. quicktype is een meertalige structuurgenerator; deze tool schakelt de just-types en no-comments opties in voor Swift, dus de uitvoer is schone struct/class eigenschapsdeclaraties zonder serialisatieannotaties zoals Codable, Decodable of Encodable, en zonder import-instructies of kopopmerkingen. Deze "pure typen" stellen ontwikkelaars in staat vrijelijk protocollen toe te voegen, toegangscontrole aan te passen of naamconventies te wijzigen op basis van netwerkframeworkvoorkeuren zoals Alamofire / Moya.
Swift's typesysteem staat bekend om zijn veiligheid. struct is een waardetype, geschikt voor het vertegenwoordigen van onveranderlijke gegevens; class is een referentietype, geschikt voor scenario's die gedeelde status of overerving vereisen. Door deze tool gegenereerde eigenschappen worden zo nauwkeurig mogelijk toegewezen aan Swift's String, Int, Double, Bool, [T], aangepaste typen, enz. Na generatie kunnen ontwikkelaars bepaalde velden wijzigen naar Optional (?) op basis van zakelijke behoeften, het Codable-protocol aan typen toevoegen, of een hele struct promoveren naar class om referentiesemantiek te verkrijgen.
Het behandelen van geneste objecten is een kernmogelijkheid van de tool. Wanneer JSON geneste objecten bevat, genereert de tool recursief onafhankelijke subtypen; wanneer Root bijvoorbeeld een address-object bevat, wordt een Address-type gegenereerd en verwijst het hoofdtype ernaar via var address: Address. Dit voorkomt dubbele type-definities en zorgt ervoor dat Xcode's autocomplete en typecontrole hiërarchische relaties correct kunnen volgen. De naamgevingsregel plaatst de eerste letter van de veldnaam in hoofdletters; elementen in een users-array worden bijvoorbeeld User genoemd.
Arraytype-inferentie volgt een "afleiden van het eerste element" strategie. Als array-elementen strings zijn, wordt [String] gegenereerd; als gehele getallen, [Int]; als zwevendekommagetallen, [Double]; als objecten, [aangepast type]. Lege arrays [] hebben geen monsters, dus wordt [Any] of een fallback-type gegenereerd; na generatie wordt aanbevolen ze te wijzigen naar concrete typen op basis van echte bedrijfslogica. Voor bijzonder grote of schaarse arrays wordt aanbevolen echte voorbeeld-elementen in de bron-JSON in te voegen om de inferentienauwkeurigheid te verbeteren.
Pure frontendverwerking is het centrale architectonische voordeel van deze tool. Alle JSON-parsing en Swift-codegeneratie worden uitgevoerd in browser-JavaScript (inclusief quicktype-core in een Web Worker), onafhankelijk van backendservices, en er worden geen gegevens naar een server verzonden. Dit ontwerp beschermt JSON-gegevens die gevoelige informatie kunnen bevatten en zorgt ervoor dat conversiesnelheid alleen wordt beperkt door lokale apparaatprestaties, zonder te wachten op netwerkreizen. Dit is vooral belangrijk bij het verwerken van JSON die API-sleutels of niet-gepubliceerde bedrijfsvelden bevat.
In tegenstelling tot sommige online tools die Codable / CodingKeys / Date decoderingsstrategieën forceren, houdt deze tool zich aan een principe van minimale uitvoer: teamleden hebben vaak verschillende voorkeuren voor protocollen, naamgeving en toegangscontrole, en deze tool laat protocolkeuzes en strategieën over aan ontwikkelaars voor verfijning per project. Deze workflow "genereer een halffabrikaat + postverwerking op projectniveau" is over het algemeen populairder bij ingenieurs in middelgrote en grote teams dan alles-in-één-klik oplossingen.
Meest gebruikelijk in iOS/macOS-projecten: voeg Codable toe aan door deze tool gegenereerde structs, haal dan asynchroon op met URLSession en decodeer met JSONDecoder.
import Foundation
// 1) Root-type gegenereerd door deze tool (met Codable-protocol toegevoegd)
struct User: Codable {
let id: Int
let name: String
let email: String
let isActive: Bool
let tags: [String]
}
// 2) Asynchroon ophalen en decoderen URLSession
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) Gebruiksvoorbeeld (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)
}
}Bij gebruik van Alamofire kunt u responseDecodable direct gebruiken om door deze tool gegenereerde structs automatisch te deserialiseren naar Swift-objecten.
import Foundation
import Alamofire
// Type gegenereerd door deze tool, direct bruikbaar na toevoegen van 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 stijl 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-stijl aanroepvoorbeeld
// provider.request(.product(id: 1)).map(Product.self)
// let product: Product = try await provider.request(.product(id: 1)).map(Product.self)In SwiftUI / Combine-projecten kunt u gegenereerde structs gebruiken samen met dataTaskPublisher / decode voor reactieve gegevensstromen.
import Foundation
import Combine
// Root-type gegenereerd door deze 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
}
/// Gegevensstroom blootleggen met 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()
}
/// Abonneren 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?
}Plak uw JSON-inhoud in het invoervak links. Na een debounce van 400ms roept de tool automatisch quicktype-core aan om het om te zetten naar Swift-code en toont het resultaat in realtime in het rechterpaneel. U kunt ook op de uploadknop klikken om een .json / .txt-bestand te selecteren, of op de voorbeeldknop klikken om ingebouwde gegevens te laden. Nadat de conversie is voltooid, kunt u het resultaat kopiëren of downloaden als .swift-bestand met één klik.
Standaard niet. Deze tool gebruikt de just-types modus van quicktype-core, die pure struct/class eigenschapsdeclaraties produceert zonder Codable, Decodable of Encodable annotaties, en zonder import-instructies. Als u Codable nodig hebt, voegt u gewoon : Codable toe na generatie (bv. struct User: Codable {}), of schrijft u uw eigen parsing-logica met JSONDecoder.
Alle geldige JSON wordt ondersteund: basistypen (null, boolean, number, string), eendimensionale of multidimensionale arrays en geneste objecten van willekeurige diepte. Root-invoer kan een JSON-object of JSON-array zijn; de tool geeft prioriteit aan objecten en leidt arrays af van hun eerste element. Niet-ondersteunde invoer omvat JavaScript-speciale waarden (functies, Symbol, undefined) en niet-JSON-tekst.
De tool genereert recursief onafhankelijke Swift-typen voor elk genest object. Naamgeving is gebaseerd op een combinatie van de bovenliggende typenaam en veldnamen; als Root bijvoorbeeld een address-veld bevat, wordt een Address-subtype gegenereerd en verwijst het hoofdtype ernaar via var address: Address. Dit voorkomt dubbele type-definities en zorgt ervoor dat Xcode's autocomplete en typecontrole hiërarchische relaties correct kunnen volgen.
Ja. JSON-arrays worden automatisch geconverteerd naar Swift's [T]-vorm. Als array-elementen strings zijn, wordt [String] gegenereerd; als gehele getallen, [Int]; als zwevendekommagetallen, [Double]; als objecten, [aangepast type]. Lege arrays [] hebben geen voorbeeld-elementen, dus wordt standaard [Any] gegenereerd; na generatie wordt aanbevolen ze handmatig te wijzigen naar een concreet type zoals [String] of [Int].
Null-waarden in JSON kunnen hun concrete type niet afleiden; de tool kan Any of een fallback-type genereren. Aanbevolen wordt om velden met null-waarde in de bron-JSON te vervangen door voorbeeldwaarden (bv. "field": "" leidt String af) of ze handmatig te wijzigen naar Optional op basis van bedrijfslogica (bv. var phone: String?), wat beter aansluit bij de veiligheidssemantiek van Swift's typesysteem.
Ja. Klik op de knop voor typenaam (of instellingeninvoer) in de werkbalk om de naam van het root-type te wijzigen (standaard is Root of afgeleid van voorbeeldgegevens). Subtype-namen worden automatisch gegenereerd op basis van de rootnaam en veldnamen; de naamgevingsregel is de eerste letter van de veldnaam in hoofdletters, bv. users → User, tags → Tag.
De tool detecteert automatisch de geldigheid van JSON; bij een fout wordt een specifieke foutmelding rechts weergegeven en wordt een knop "JSON herstellen" geboden. Door te klikken worden veelvoorkomende fouten automatisch hersteld: trailing komma's, enkele aanhalingstekens vervangen door dubbele, ontbrekende aanhalingstekens rond sleutels, verwijderen van opmerkingen, enz. Na succesvol herstel kunt u doorgaan met converteren zonder JSON handmatig te corrigeren.
Draait volledig in uw browser. Alle JSON-parsing en Swift-codegeneratie gebeuren lokaal via browser-JavaScript (inclusief quicktype-core in een Web Worker); de JSON die u invoert en de gegenereerde Swift-code worden nooit naar een server verzonden, noch gelogd of in de cloud gecached. Gevoelige JSON met API-sleutels, tokens, gebruikersprivacyvelden of niet-gepubliceerde bedrijfsstructuren kan veilig worden gebruikt — de pagina sluiten wist alles.
Ja. Gegenereerde code is standaard Swift-syntaxis en kan direct naar een Xcode .swift-bestand worden gekopieerd, of via de knop "Downloaden" als .swift-bestand worden opgeslagen en naar uw project gesleept. Aangezien de uitvoer pure type-declaraties zijn, wordt aanbevolen handmatig protocollen zoals Codable, Equatable, Identifiable toe te voegen indien nodig, of toegangscontrolemodificatoren aan te passen (public / internal / private).
Ja. Wanneer de root-invoer een JSON-array is, gebruikt de tool het eerste element van de array als sjabloon om een elementtype te genereren en geeft de definitie van dat elementtype. [{"id":1,"name":"A"}] genereert bijvoorbeeld een struct genaamd Item (of een naam afgeleid van velden) waarvan de velden die van het eerste element zijn; het hoofdtype verwijst ernaar via een items: [Item] eigenschap, waardoor wordt voorkomen dat de array direct als root-type wordt behandeld.
Er is geen expliciete groottelimiet, maar de browser wordt trager bij het parsen en weergeven van zeer grote JSON. Aanbevelingen: ① Converteer per keer JSON van slechts één bedrijfsmodule; ② Splits diepe geneste niveaus en verwerk ze afzonderlijk; ③ Voor JSON boven enkele MB kunt u de quicktype commandoregelversie gebruiken; ④ Dezelfde JSON opsplitsen in meerdere submodules en afzonderlijk converteren kan geheugengebruik aanzienlijk verminderen.
Beide converteren JSON naar typedefinities voor hun respectievelijke talen, maar hun focus verschilt: JSON naar Swift genereert struct/class eigenschapsdeclaraties voor native iOS/macOS-apps; JSON naar TypeScript genereert interface/type declaraties voor frontend-typecontrole. Als uw project zowel een iOS-client als een web-frontend heeft, wordt aanbevolen om Swift- en TS-versies te genereren vanuit dezelfde JSON om typeconsistentie aan beide zijden te waarborgen.
Deze tool genereert standaard pure typen zonder protocollen. Na generatie hoeft u alleen : Codable toe te voegen na de struct/class-declaratie, bv. struct User: Codable {}, en JSONDecoder kan het gebruiken. Als u standaard Codable wilt, kunt u quicktype-core forken en de Swift-renderer aanpassen, of Xcode's bulksgewijze vervanging gebruiken om het protocol aan alle typen toe te voegen na generatie.
Eerste bezoek vereist internet om de toolscripts en quicktype-core bronnen te laden; daarna kan het offline werken vanuit de browsercache (in een reeds bezochte browser). Mobiele browsers (iOS Safari, Android Chrome) werken ook normaal; de interface gebruikt een responsief gesplitst ontwerp dat automatisch overschakelt naar verticale stapeling in portretoriëntatie.
Ja. Na generatie is elk Swift-type een onafhankelijke struct/class; de tooluitvoer is platte tekst. U kunt afzonderlijk een enkel type kopiëren en in Xcode plakken, of Xcode's Rename-refactoring gebruiken om typen en velden bulksgewijs te wijzigen zonder andere typen te beïnvloeden. Als u de hele typegroep opnieuw moet genereren, vernieuwt u gewoon de pagina en plakt u de JSON opnieuw.
quicktype's ondersteuning voor unions/enums vereist extra type-hints of GraphQL/JSON Schema-invoer. Enums afleiden alleen uit JSON-monsters is moeilijk, dus deze tool genereert standaard geen enums. Als u enums nodig hebt, kunt u de bijbehorende struct handmatig wijzigen naar een enum + Codable, of eerst een JSON naar Kotlin/TypeScript-tool gebruiken om enum-typen te verkrijgen en ze vervolgens handmatig naar Swift te migreren.
Het invoervak links is leeg of bevat alleen witruimte. Plak geldige JSON-inhoud, of klik op "Voorbeeld" om een voorbeeld te laden, of op "Uploaden" om een .json / .txt-bestand te selecteren.
De JSON is onjuist opgemaakt. Veelvoorkomende oorzaken: ① trailing komma (bv. {"a":1,}); ② enkele aanhalingstekens gebruikt in plaats van dubbele; ③ JS-objectsyntaxis (bv. {key: value}) in plaats van JSON (bv. {"key": "value"}); ④ JavaScript-opmerkingen bevat. Klikken op de knop "JSON herstellen" kan enkele veelvoorkomende fouten automatisch herstellen.
Dit is verwacht gedrag. Deze tool gebruikt de just-types modus en genereert pure struct/class eigenschapsdeclaraties. Als u Codable nodig hebt, voegt u : Codable toe aan typen na generatie (bv. struct User: Codable {}), of schrijft u extension User: Codable {} voordat u JSONDecoder aanroept.
Lege arrays hebben geen voorbeeld-elementen, dus de tool genereert het fallback-type [Any]. Aanbevolen wordt om ten minste één voorbeeld-element in de bron-JSON in te voegen (bv. [1, 2]), de voorbeeldwaarde na generatie te verwijderen en handmatig een concreet type op te geven; of direct na generatie te wijzigen naar een nauwkeuriger type zoals [String] / [User].
JSON null kan geen concreet type afleiden; de tool kan Any of een fallback-type genereren. Aanbevolen wordt om null in de bron-JSON te vervangen door een representatieve voorbeeldwaarde (bv. "" of 0), en dat veld na generatie te wijzigen naar Optional (?) of een concreet type, bv. var phone: String?.
U kunt de naam van het root-type wijzigen in de werkbalk; subtype-namen worden automatisch gegenereerd op basis van rootnaam + veldnamen. Als u nog steeds ontevreden bent, gebruikt u Xcode's Rename-refactoring voor bulksgewijze wijziging na generatie (rechtsklik → Refactor → Rename); Xcode werkt alle verwijzingen synchroon bij.
De browser wordt trager bij het weergeven van zeer grote JSON en het genereren van veel typen. Aanbevolen wordt JSON op te splitsen in meerdere onafhankelijke bedrijfsmodules en ze afzonderlijk te converteren, of alleen sleutelobjecten te extraheren die modellering nodig hebben; voor JSON boven 10 MB wordt de quicktype commandoregelversie aanbevolen.
Betekent dat u Codable aan sommige velden hebt toegevoegd maar Optional / Date / Enum-typen niet correct hebt behandeld. Veelvoorkomende oplossingen: ① Wijzig alle velden die null kunnen zijn naar Optional<T>; ② Pas de datumstrategie aan met JSONDecoder().dateDecodingStrategy = .iso8601; ③ Pas CodingKeys aan om JSON-sleutels uit te lijnen met Swift-eigenschapnamen.
Deze tool behoudt standaard originele JSON-veldnamen, dus snake_case-velden worden zoals gegenereerd. Als u wilt uniformeren naar camelCase kunt u na generatie bulksgewijs hernoemen met Xcode's Rename, of veldnamen naar camelCase converteren in een aangepaste quicktype-renderer, voeg vervolgens CodingKeys-toewijzingen toe om correcte JSON-decodering te garanderen.
Swift beveelt ASCII Engelse veldnamen aan als identifiers. Als bron-JSON Chinese sleutels bevat (bv. {"姓名": "Alice"}), zal de gegenereerde var 姓名: String compileerfouten veroorzaken in sommige oudere versies. Aanbevolen wordt sleutels te wijzigen naar Engels (bv. name) in de bron-JSON, wat meer in overeenstemming is met Swift-coderingsstandaarden.
Deze tool genereert standaard public var eigenschappen voor eenvoudige naverwerking. Als u let of toegangscontrole wilt (bv. private(set)), kunt u na generatie bulksgewijs wijzigen met Xcode Refactor → Add Access Control, of var vervangen door let met sed / een tekstedithulpmiddel na generatie.
Deze tool wijst ISO 8601 strings standaard toe aan String; Swift converteert ze niet automatisch naar Date. U moet dateDecodingStrategy instellen op JSONDecoder, bv. JSONDecoder().dateDecodingStrategy = .iso8601. Als het datumformaat niet standaard is, moet u ook handmatig een DateFormatter of aangepaste parsing-logica implementeren.
De tool benoemt subtypen door "de eerste letter van de veldnaam in hoofdletters te plaatsen". Diep geneste JSON kan geneste objecten met dezelfde naam hebben, waardoor typeconflicten ontstaan. Oplossingen: ① Voeg zakelijke voorvoegsels toe aan velden in bron-JSON; ② Splits root-JSON in meerdere onafhankelijke modules en genereer afzonderlijk; ③ Gebruik Xcode's Rename om conflicterende typenamen na generatie bulksgewijs te wijzigen.
Deze tool genereert standaard internal struct zonder expliciete public-modificator. Als uw project is verdeeld in modules en cross-module toegang vereist, moet u in Xcode bulksgewijs struct vervangen door public struct, of na generatie uniform het public-sleutelwoord toevoegen met sed/awk-scripts.
De tool leidt automatisch bijbehorende Swift-typen af op basis van de vorm van JSON-waarden:
| JSON-waarde voorbeeld | Detectiemethode | Gegenereerd Swift-type | Opmerkingen |
|---|---|---|---|
null | value === null | Any? of concrete Optional | Kan geen concreet type afleiden; aanbevolen na generatie handmatig te wijzigen naar Optional<T> |
true / false | typeof value === 'boolean' | Bool | Direct toegewezen aan Swift's Bool-type |
42 | typeof value === 'number' && Number.isInteger(value) | Int | Gehele getallen worden toegewezen aan Int (32/64 bits bepaald door platform) |
3.14 | typeof value === 'number' && !Number.isInteger(value) | Double | Zwevendekommagetallen worden toegewezen aan Double |
"hello" | typeof value === 'string' | String | Strings worden toegewezen aan String |
[] (lege array) | Array.isArray(value) && value.length === 0 | [Any] | Kan geen elementtype afleiden; aanbevolen voorbeeld toe te voegen of handmatig te wijzigen naar concreet type |
["a", "b"] | Array.isArray(value) && typeof value[0] === 'string' | [String] | Array van strings |
[1, 2, 3] | Array.isArray(value) && typeof value[0] === 'number' | [Int] | Array van gehele getallen |
[1.5, 2.5] | Array.isArray(value) && typeof value[0] === 'number' && !Number.isInteger(value[0]) | [Double] | Array van floats |
[{...}, {...}] | Array.isArray(value) && typeof value[0] === 'object' | [Item] | Array van objecten, elementen zijn aangepaste typen, namen afgeleid van veldnamen |
{...} (genest object) | typeof value === 'object' && !Array.isArray(value) | Onafhankelijke struct / class | Genereert recursief onafhankelijke typen, benoemd met eerste letter van veld in hoofdletters |
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 |
Deze JSON naar Swift-tool voert alle JSON-parsing en Swift-typegeneratie volledig uit in uw browser via JavaScript (quicktype-core / Web Worker). De JSON-gegevens die u invoert en de gegenereerde Swift-code worden nooit naar een server verzonden, noch gelogd, gecached of in de cloud opgeslagen. Gevoelige JSON met interne API-velden, API-sleutels, tokens, gebruikersprivacygegevens of niet-gepubliceerde bedrijfsstructuren kan veilig worden gebruikt; alle invoer- en uitvoerinhoud wordt automatisch uit het geheugen gewist wanneer u de pagina sluit of vernieuwt, zonder afhankelijk te zijn van netwerkservices van derden.