{"id":58200,"date":"2021-10-09T12:52:47","date_gmt":"2021-10-09T10:52:47","guid":{"rendered":"https:\/\/tissi.de\/privacy-policy\/"},"modified":"2026-06-25T04:47:54","modified_gmt":"2026-06-25T02:47:54","slug":"privacy-policy","status":"publish","type":"page","link":"https:\/\/tissi.de\/en\/privacy-policy\/","title":{"rendered":"Privacy Policy"},"content":{"rendered":"<div class=\"wpb-content-wrapper\"><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-58200","page","type-page","status-publish","hentry"],"acf":[],"yoast_head":"<!-- This site is optimized with the Yoast SEO plugin v28.0 - https:\/\/yoast.com\/product\/yoast-seo-wordpress\/ -->\n<title>Privacy Policy - tiSsi\u00ae<\/title>\n<meta name=\"description\" content=\"We take data protection seriously when you use our website. We have compiled all the relevant information for you here.\" \/>\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\/en\/privacy-policy\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Privacy Policy - tiSsi\u00ae\" \/>\n<meta property=\"og:description\" content=\"We take data protection seriously when you use our website. We have compiled all the relevant information for you here.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/tissi.de\/en\/privacy-policy\/\" \/>\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-06-25T02:47:54+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=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data1\" content=\"61 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/tissi.de\\\/en\\\/privacy-policy\\\/\",\"url\":\"https:\\\/\\\/tissi.de\\\/en\\\/privacy-policy\\\/\",\"name\":\"Privacy Policy - tiSsi\u00ae\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/tissi.de\\\/en\\\/#website\"},\"datePublished\":\"2021-10-09T10:52:47+00:00\",\"dateModified\":\"2026-06-25T02:47:54+00:00\",\"description\":\"We take data protection seriously when you use our website. We have compiled all the relevant information for you here.\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/tissi.de\\\/en\\\/privacy-policy\\\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/tissi.de\\\/en\\\/privacy-policy\\\/\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/tissi.de\\\/en\\\/privacy-policy\\\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Startseite\",\"item\":\"https:\\\/\\\/tissi.de\\\/en\\\/home\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Privacy Policy\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/tissi.de\\\/en\\\/#website\",\"url\":\"https:\\\/\\\/tissi.de\\\/en\\\/\",\"name\":\"tiSsi\u00ae\",\"description\":\"Familie beginnt mit uns! Lernturm, Hochstuhl, Kinderm\u00f6bel, Laufgitter\",\"publisher\":{\"@id\":\"https:\\\/\\\/tissi.de\\\/en\\\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/tissi.de\\\/en\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"en-US\"},{\"@type\":\"Organization\",\"@id\":\"https:\\\/\\\/tissi.de\\\/en\\\/#organization\",\"name\":\"M.J. Oster GmbH\",\"url\":\"https:\\\/\\\/tissi.de\\\/en\\\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/tissi.de\\\/en\\\/#\\\/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\":188,\"caption\":\"M.J. Oster GmbH\"},\"image\":{\"@id\":\"https:\\\/\\\/tissi.de\\\/en\\\/#\\\/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":"Privacy Policy - tiSsi\u00ae","description":"We take data protection seriously when you use our website. We have compiled all the relevant information for you here.","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\/en\/privacy-policy\/","og_locale":"en_US","og_type":"article","og_title":"Privacy Policy - tiSsi\u00ae","og_description":"We take data protection seriously when you use our website. We have compiled all the relevant information for you here.","og_url":"https:\/\/tissi.de\/en\/privacy-policy\/","og_site_name":"tiSsi\u00ae","article_publisher":"https:\/\/de-de.facebook.com\/tiSsikids\/","article_modified_time":"2026-06-25T02:47:54+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":{"Est. reading time":"61 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"WebPage","@id":"https:\/\/tissi.de\/en\/privacy-policy\/","url":"https:\/\/tissi.de\/en\/privacy-policy\/","name":"Privacy Policy - tiSsi\u00ae","isPartOf":{"@id":"https:\/\/tissi.de\/en\/#website"},"datePublished":"2021-10-09T10:52:47+00:00","dateModified":"2026-06-25T02:47:54+00:00","description":"We take data protection seriously when you use our website. We have compiled all the relevant information for you here.","breadcrumb":{"@id":"https:\/\/tissi.de\/en\/privacy-policy\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/tissi.de\/en\/privacy-policy\/"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/tissi.de\/en\/privacy-policy\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Startseite","item":"https:\/\/tissi.de\/en\/home\/"},{"@type":"ListItem","position":2,"name":"Privacy Policy"}]},{"@type":"WebSite","@id":"https:\/\/tissi.de\/en\/#website","url":"https:\/\/tissi.de\/en\/","name":"tiSsi\u00ae","description":"Familie beginnt mit uns! Lernturm, Hochstuhl, Kinderm\u00f6bel, Laufgitter","publisher":{"@id":"https:\/\/tissi.de\/en\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/tissi.de\/en\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":"Organization","@id":"https:\/\/tissi.de\/en\/#organization","name":"M.J. Oster GmbH","url":"https:\/\/tissi.de\/en\/","logo":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/tissi.de\/en\/#\/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":188,"caption":"M.J. Oster GmbH"},"image":{"@id":"https:\/\/tissi.de\/en\/#\/schema\/logo\/image\/"},"sameAs":["https:\/\/de-de.facebook.com\/tiSsikids\/","https:\/\/www.instagram.com\/tissi_kids\/"]}]}},"_links":{"self":[{"href":"https:\/\/tissi.de\/en\/wp-json\/wp\/v2\/pages\/58200","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/tissi.de\/en\/wp-json\/wp\/v2\/pages"}],"about":[{"href":"https:\/\/tissi.de\/en\/wp-json\/wp\/v2\/types\/page"}],"author":[{"embeddable":true,"href":"https:\/\/tissi.de\/en\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/tissi.de\/en\/wp-json\/wp\/v2\/comments?post=58200"}],"version-history":[{"count":1,"href":"https:\/\/tissi.de\/en\/wp-json\/wp\/v2\/pages\/58200\/revisions"}],"predecessor-version":[{"id":58203,"href":"https:\/\/tissi.de\/en\/wp-json\/wp\/v2\/pages\/58200\/revisions\/58203"}],"wp:attachment":[{"href":"https:\/\/tissi.de\/en\/wp-json\/wp\/v2\/media?parent=58200"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}