{"id":60387,"date":"2021-10-09T12:52:47","date_gmt":"2021-10-09T10:52:47","guid":{"rendered":"https:\/\/tissi.de\/dataskydd\/"},"modified":"2026-09-02T05:13:39","modified_gmt":"2026-09-02T03:13:39","slug":"dataskydd","status":"publish","type":"page","link":"https:\/\/tissi.de\/sv\/dataskydd\/","title":{"rendered":"Dataskydd"},"content":{"rendered":"<div class=\"wpb-content-wrapper\" id=\"wpb-content-root\"><p>[vc_section][vc_row][vc_column width=&#8221;1\/1&#8243;][vc_raw_html]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[\/vc_raw_html][\/vc_column][\/vc_row][\/vc_section]<\/p>\n<\/div>","protected":false},"excerpt":{"rendered":"<p>[vc_section][vc_row][vc_column width=&#8221;1\/1&#8243;][vc_raw_html]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[\/vc_raw_html][\/vc_column][\/vc_row][\/vc_section]<\/p>\n","protected":false},"author":1,"featured_media":0,"parent":0,"menu_order":0,"comment_status":"closed","ping_status":"closed","template":"","meta":{"_acf_changed":false,"inline_featured_image":false,"footnotes":""},"class_list":["post-60387","page","type-page","status-publish","hentry"],"acf":[],"yoast_head":"<!-- This site is optimized with the Yoast SEO plugin v28.3 - https:\/\/yoast.com\/product\/yoast-seo-wordpress\/ -->\n<title>Dataskydd - tiSsi\u00ae<\/title>\n<meta name=\"description\" content=\"Vi l\u00e4gger stor vikt vid integritetsskyddet n\u00e4r du anv\u00e4nder v\u00e5r webbplats. H\u00e4r har vi sammanst\u00e4llt all relevant information \u00e5t dig.\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/tissi.de\/sv\/dataskydd\/\" \/>\n<meta property=\"og:locale\" content=\"sv_SE\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Dataskydd - tiSsi\u00ae\" \/>\n<meta property=\"og:description\" content=\"Vi l\u00e4gger stor vikt vid integritetsskyddet n\u00e4r du anv\u00e4nder v\u00e5r webbplats. H\u00e4r har vi sammanst\u00e4llt all relevant information \u00e5t dig.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/tissi.de\/sv\/dataskydd\/\" \/>\n<meta property=\"og:site_name\" content=\"tiSsi\u00ae\" \/>\n<meta property=\"article:publisher\" content=\"https:\/\/de-de.facebook.com\/tiSsikids\/\" \/>\n<meta property=\"article:modified_time\" content=\"2026-09-02T03:13:39+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/tissi.de\/wp-content\/uploads\/2022\/04\/family-business-tissi.jpg\" \/>\n\t<meta property=\"og:image:width\" content=\"681\" \/>\n\t<meta property=\"og:image:height\" content=\"418\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/jpeg\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Ber\u00e4knad l\u00e4stid\" \/>\n\t<meta name=\"twitter:data1\" content=\"64 minuter\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/tissi.de\\\/sv\\\/dataskydd\\\/\",\"url\":\"https:\\\/\\\/tissi.de\\\/sv\\\/dataskydd\\\/\",\"name\":\"Dataskydd - tiSsi\u00ae\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/tissi.de\\\/sv\\\/#website\"},\"datePublished\":\"2021-10-09T10:52:47+00:00\",\"dateModified\":\"2026-09-02T03:13:39+00:00\",\"description\":\"Vi l\u00e4gger stor vikt vid integritetsskyddet n\u00e4r du anv\u00e4nder v\u00e5r webbplats. H\u00e4r har vi sammanst\u00e4llt all relevant information \u00e5t dig.\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/tissi.de\\\/sv\\\/dataskydd\\\/#breadcrumb\"},\"inLanguage\":\"sv-SE\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/tissi.de\\\/sv\\\/dataskydd\\\/\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/tissi.de\\\/sv\\\/dataskydd\\\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Startseite\",\"item\":\"https:\\\/\\\/tissi.de\\\/sv\\\/hem\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Dataskydd\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/tissi.de\\\/sv\\\/#website\",\"url\":\"https:\\\/\\\/tissi.de\\\/sv\\\/\",\"name\":\"tiSsi\u00ae\",\"description\":\"Familie beginnt mit uns! Lernturm, Hochstuhl, Kinderm\u00f6bel, Laufgitter\",\"publisher\":{\"@id\":\"https:\\\/\\\/tissi.de\\\/sv\\\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/tissi.de\\\/sv\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"sv-SE\"},{\"@type\":\"Organization\",\"@id\":\"https:\\\/\\\/tissi.de\\\/sv\\\/#organization\",\"name\":\"M.J. Oster GmbH\",\"url\":\"https:\\\/\\\/tissi.de\\\/sv\\\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"sv-SE\",\"@id\":\"https:\\\/\\\/tissi.de\\\/sv\\\/#\\\/schema\\\/logo\\\/image\\\/\",\"url\":\"https:\\\/\\\/tissi.de\\\/wp-content\\\/uploads\\\/2022\\\/04\\\/tissi-logo.webp\",\"contentUrl\":\"https:\\\/\\\/tissi.de\\\/wp-content\\\/uploads\\\/2022\\\/04\\\/tissi-logo.webp\",\"width\":300,\"height\":173,\"caption\":\"M.J. Oster GmbH\"},\"image\":{\"@id\":\"https:\\\/\\\/tissi.de\\\/sv\\\/#\\\/schema\\\/logo\\\/image\\\/\"},\"sameAs\":[\"https:\\\/\\\/de-de.facebook.com\\\/tiSsikids\\\/\",\"https:\\\/\\\/www.instagram.com\\\/tissi_kids\\\/\"]}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Dataskydd - tiSsi\u00ae","description":"Vi l\u00e4gger stor vikt vid integritetsskyddet n\u00e4r du anv\u00e4nder v\u00e5r webbplats. H\u00e4r har vi sammanst\u00e4llt all relevant information \u00e5t dig.","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/tissi.de\/sv\/dataskydd\/","og_locale":"sv_SE","og_type":"article","og_title":"Dataskydd - tiSsi\u00ae","og_description":"Vi l\u00e4gger stor vikt vid integritetsskyddet n\u00e4r du anv\u00e4nder v\u00e5r webbplats. H\u00e4r har vi sammanst\u00e4llt all relevant information \u00e5t dig.","og_url":"https:\/\/tissi.de\/sv\/dataskydd\/","og_site_name":"tiSsi\u00ae","article_publisher":"https:\/\/de-de.facebook.com\/tiSsikids\/","article_modified_time":"2026-09-02T03:13:39+00:00","og_image":[{"width":681,"height":418,"url":"https:\/\/tissi.de\/wp-content\/uploads\/2022\/04\/family-business-tissi.jpg","type":"image\/jpeg"}],"twitter_card":"summary_large_image","twitter_misc":{"Ber\u00e4knad l\u00e4stid":"64 minuter"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"WebPage","@id":"https:\/\/tissi.de\/sv\/dataskydd\/","url":"https:\/\/tissi.de\/sv\/dataskydd\/","name":"Dataskydd - tiSsi\u00ae","isPartOf":{"@id":"https:\/\/tissi.de\/sv\/#website"},"datePublished":"2021-10-09T10:52:47+00:00","dateModified":"2026-09-02T03:13:39+00:00","description":"Vi l\u00e4gger stor vikt vid integritetsskyddet n\u00e4r du anv\u00e4nder v\u00e5r webbplats. H\u00e4r har vi sammanst\u00e4llt all relevant information \u00e5t dig.","breadcrumb":{"@id":"https:\/\/tissi.de\/sv\/dataskydd\/#breadcrumb"},"inLanguage":"sv-SE","potentialAction":[{"@type":"ReadAction","target":["https:\/\/tissi.de\/sv\/dataskydd\/"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/tissi.de\/sv\/dataskydd\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Startseite","item":"https:\/\/tissi.de\/sv\/hem\/"},{"@type":"ListItem","position":2,"name":"Dataskydd"}]},{"@type":"WebSite","@id":"https:\/\/tissi.de\/sv\/#website","url":"https:\/\/tissi.de\/sv\/","name":"tiSsi\u00ae","description":"Familie beginnt mit uns! Lernturm, Hochstuhl, Kinderm\u00f6bel, Laufgitter","publisher":{"@id":"https:\/\/tissi.de\/sv\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/tissi.de\/sv\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"sv-SE"},{"@type":"Organization","@id":"https:\/\/tissi.de\/sv\/#organization","name":"M.J. Oster GmbH","url":"https:\/\/tissi.de\/sv\/","logo":{"@type":"ImageObject","inLanguage":"sv-SE","@id":"https:\/\/tissi.de\/sv\/#\/schema\/logo\/image\/","url":"https:\/\/tissi.de\/wp-content\/uploads\/2022\/04\/tissi-logo.webp","contentUrl":"https:\/\/tissi.de\/wp-content\/uploads\/2022\/04\/tissi-logo.webp","width":300,"height":173,"caption":"M.J. Oster GmbH"},"image":{"@id":"https:\/\/tissi.de\/sv\/#\/schema\/logo\/image\/"},"sameAs":["https:\/\/de-de.facebook.com\/tiSsikids\/","https:\/\/www.instagram.com\/tissi_kids\/"]}]}},"jetpack_sharing_enabled":true,"_links":{"self":[{"href":"https:\/\/tissi.de\/sv\/wp-json\/wp\/v2\/pages\/60387","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/tissi.de\/sv\/wp-json\/wp\/v2\/pages"}],"about":[{"href":"https:\/\/tissi.de\/sv\/wp-json\/wp\/v2\/types\/page"}],"author":[{"embeddable":true,"href":"https:\/\/tissi.de\/sv\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/tissi.de\/sv\/wp-json\/wp\/v2\/comments?post=60387"}],"version-history":[{"count":2,"href":"https:\/\/tissi.de\/sv\/wp-json\/wp\/v2\/pages\/60387\/revisions"}],"predecessor-version":[{"id":60389,"href":"https:\/\/tissi.de\/sv\/wp-json\/wp\/v2\/pages\/60387\/revisions\/60389"}],"wp:attachment":[{"href":"https:\/\/tissi.de\/sv\/wp-json\/wp\/v2\/media?parent=60387"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}