{"id":45991,"date":"2021-06-05T03:10:53","date_gmt":"2021-06-05T10:10:53","guid":{"rendered":"https:\/\/www.terabyteunlimited.com\/howto\/een-terabyte-herstelomgeving-winre-opstartschijf-of-ufd-met-image-for-windows-tbwinre-maken\/"},"modified":"2026-10-10T18:15:35","modified_gmt":"2026-10-11T01:15:35","slug":"tbwinre_tutorial","status":"publish","type":"page","link":"https:\/\/www.terabyteunlimited.com\/nl\/howto\/tbwinre_tutorial\/","title":{"rendered":"Een TeraByte-herstelomgeving, WinRE-opstartschijf of UFD met Image for Windows (TBWinRE) maken"},"content":{"rendered":"<section class=\"l-section wpb_row howtoin-btn-sec height_small\"><div class=\"l-section-h i-cf\"><div class=\"g-cols vc_row via_flex valign_top type_default stacking_default\"><div class=\"vc_col-sm-12 wpb_column vc_column_container\"><div class=\"vc_column-inner\"><div class=\"wpb_wrapper\"><div class=\"g-cols wpb_row via_flex valign_top type_default stacking_default\"><div class=\"vc_col-sm-12 wpb_column vc_column_container\"><div class=\"vc_column-inner\"><div class=\"wpb_wrapper\"><div class=\"w-btn-wrapper align_none\"><a class=\"w-btn us-btn-style_1\" title=\"How+To\" href=\"\/howto\/#1622795588394-d8378605-e210\"><span class=\"w-btn-label\">Index van handleidingen<\/span><\/a><\/div><\/div><\/div><\/div><\/div><div class=\"w-separator size_small\"><\/div><div class=\"g-cols wpb_row via_flex valign_top type_default stacking_default\"><div class=\"vc_col-sm-12 wpb_column vc_column_container\"><div class=\"vc_column-inner\"><div class=\"wpb_wrapper\">[vc_raw_html]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[\/vc_raw_html]<\/div><\/div><\/div><\/div><\/div><\/div><\/div><\/div><\/div><\/section>\n","protected":false},"excerpt":{"rendered":"Index van handleidingen[vc_raw_html]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[\/vc_raw_html]","protected":false},"author":4,"featured_media":0,"parent":45765,"menu_order":0,"comment_status":"closed","ping_status":"closed","template":"","meta":{"footnotes":""},"class_list":["post-45991","page","type-page","status-publish","hentry"],"yoast_head":"<!-- This site is optimized with the Yoast SEO Premium plugin v28.7 (Yoast SEO v28.7) - https:\/\/yoast.com\/product\/yoast-seo-premium-wordpress\/ -->\n<title>Een TeraByte-herstelomgeving, WinRE-opstartschijf of UFD met Image for Windows (TBWinRE) maken - TeraByte Unlimited<\/title>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/www.terabyteunlimited.com\/nl\/howto\/tbwinre_tutorial\/\" \/>\n<meta property=\"og:locale\" content=\"nl_NL\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Een TeraByte-herstelomgeving, WinRE-opstartschijf of UFD met Image for Windows (TBWinRE) maken\" \/>\n<meta property=\"og:url\" content=\"https:\/\/www.terabyteunlimited.com\/nl\/howto\/tbwinre_tutorial\/\" \/>\n<meta property=\"og:site_name\" content=\"TeraByte Unlimited\" \/>\n<meta property=\"article:publisher\" content=\"https:\/\/www.facebook.com\/terabyteunlimited\" \/>\n<meta property=\"article:modified_time\" content=\"2026-10-11T01:15:35+00:00\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Geschatte leestijd\" \/>\n\t<meta name=\"twitter:data1\" content=\"53 minuten\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/www.terabyteunlimited.com\\\/nl\\\/howto\\\/tbwinre_tutorial\\\/\",\"url\":\"https:\\\/\\\/www.terabyteunlimited.com\\\/nl\\\/howto\\\/tbwinre_tutorial\\\/\",\"name\":\"Een TeraByte-herstelomgeving, WinRE-opstartschijf of UFD met Image for Windows (TBWinRE) maken - TeraByte Unlimited\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/www.terabyteunlimited.com\\\/nl\\\/#website\"},\"datePublished\":\"2021-06-05T10:10:53+00:00\",\"dateModified\":\"2026-10-11T01:15:35+00:00\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/www.terabyteunlimited.com\\\/nl\\\/howto\\\/tbwinre_tutorial\\\/#breadcrumb\"},\"inLanguage\":\"nl-NL\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/www.terabyteunlimited.com\\\/nl\\\/howto\\\/tbwinre_tutorial\\\/\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/www.terabyteunlimited.com\\\/nl\\\/howto\\\/tbwinre_tutorial\\\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\\\/\\\/www.terabyteunlimited.com\\\/nl\\\/home\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Hoe\",\"item\":\"https:\\\/\\\/www.terabyteunlimited.com\\\/nl\\\/howto\\\/\"},{\"@type\":\"ListItem\",\"position\":3,\"name\":\"Een TeraByte-herstelomgeving, WinRE-opstartschijf of UFD met Image for Windows (TBWinRE) maken\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/www.terabyteunlimited.com\\\/nl\\\/#website\",\"url\":\"https:\\\/\\\/www.terabyteunlimited.com\\\/nl\\\/\",\"name\":\"TeraByte Unlimited\",\"description\":\"Systeemback-up, harde schijven kopi\u00ebren, Opstartbeheer, Partitiebeheer, Klembordbeheer, Schermopname en meer\",\"publisher\":{\"@id\":\"https:\\\/\\\/www.terabyteunlimited.com\\\/nl\\\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/www.terabyteunlimited.com\\\/nl\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"nl-NL\"},{\"@type\":\"Organization\",\"@id\":\"https:\\\/\\\/www.terabyteunlimited.com\\\/nl\\\/#organization\",\"name\":\"TeraByte Unlimited\",\"url\":\"https:\\\/\\\/www.terabyteunlimited.com\\\/nl\\\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"nl-NL\",\"@id\":\"https:\\\/\\\/www.terabyteunlimited.com\\\/nl\\\/#\\\/schema\\\/logo\\\/image\\\/\",\"url\":\"https:\\\/\\\/www.terabyteunlimited.com\\\/wp-content\\\/uploads\\\/2021\\\/03\\\/terabyte-logo_trans.png\",\"contentUrl\":\"https:\\\/\\\/www.terabyteunlimited.com\\\/wp-content\\\/uploads\\\/2021\\\/03\\\/terabyte-logo_trans.png\",\"width\":524,\"height\":89,\"caption\":\"TeraByte Unlimited\"},\"image\":{\"@id\":\"https:\\\/\\\/www.terabyteunlimited.com\\\/nl\\\/#\\\/schema\\\/logo\\\/image\\\/\"},\"sameAs\":[\"https:\\\/\\\/www.facebook.com\\\/terabyteunlimited\"]}]}<\/script>\n<!-- \/ Yoast SEO Premium plugin. -->","yoast_head_json":{"title":"Een TeraByte-herstelomgeving, WinRE-opstartschijf of UFD met Image for Windows (TBWinRE) maken - TeraByte Unlimited","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:\/\/www.terabyteunlimited.com\/nl\/howto\/tbwinre_tutorial\/","og_locale":"nl_NL","og_type":"article","og_title":"Een TeraByte-herstelomgeving, WinRE-opstartschijf of UFD met Image for Windows (TBWinRE) maken","og_url":"https:\/\/www.terabyteunlimited.com\/nl\/howto\/tbwinre_tutorial\/","og_site_name":"TeraByte Unlimited","article_publisher":"https:\/\/www.facebook.com\/terabyteunlimited","article_modified_time":"2026-10-11T01:15:35+00:00","twitter_card":"summary_large_image","twitter_misc":{"Geschatte leestijd":"53 minuten"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"WebPage","@id":"https:\/\/www.terabyteunlimited.com\/nl\/howto\/tbwinre_tutorial\/","url":"https:\/\/www.terabyteunlimited.com\/nl\/howto\/tbwinre_tutorial\/","name":"Een TeraByte-herstelomgeving, WinRE-opstartschijf of UFD met Image for Windows (TBWinRE) maken - TeraByte Unlimited","isPartOf":{"@id":"https:\/\/www.terabyteunlimited.com\/nl\/#website"},"datePublished":"2021-06-05T10:10:53+00:00","dateModified":"2026-10-11T01:15:35+00:00","breadcrumb":{"@id":"https:\/\/www.terabyteunlimited.com\/nl\/howto\/tbwinre_tutorial\/#breadcrumb"},"inLanguage":"nl-NL","potentialAction":[{"@type":"ReadAction","target":["https:\/\/www.terabyteunlimited.com\/nl\/howto\/tbwinre_tutorial\/"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/www.terabyteunlimited.com\/nl\/howto\/tbwinre_tutorial\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/www.terabyteunlimited.com\/nl\/home\/"},{"@type":"ListItem","position":2,"name":"Hoe","item":"https:\/\/www.terabyteunlimited.com\/nl\/howto\/"},{"@type":"ListItem","position":3,"name":"Een TeraByte-herstelomgeving, WinRE-opstartschijf of UFD met Image for Windows (TBWinRE) maken"}]},{"@type":"WebSite","@id":"https:\/\/www.terabyteunlimited.com\/nl\/#website","url":"https:\/\/www.terabyteunlimited.com\/nl\/","name":"TeraByte Unlimited","description":"Systeemback-up, harde schijven kopi\u00ebren, Opstartbeheer, Partitiebeheer, Klembordbeheer, Schermopname en meer","publisher":{"@id":"https:\/\/www.terabyteunlimited.com\/nl\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/www.terabyteunlimited.com\/nl\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"nl-NL"},{"@type":"Organization","@id":"https:\/\/www.terabyteunlimited.com\/nl\/#organization","name":"TeraByte Unlimited","url":"https:\/\/www.terabyteunlimited.com\/nl\/","logo":{"@type":"ImageObject","inLanguage":"nl-NL","@id":"https:\/\/www.terabyteunlimited.com\/nl\/#\/schema\/logo\/image\/","url":"https:\/\/www.terabyteunlimited.com\/wp-content\/uploads\/2021\/03\/terabyte-logo_trans.png","contentUrl":"https:\/\/www.terabyteunlimited.com\/wp-content\/uploads\/2021\/03\/terabyte-logo_trans.png","width":524,"height":89,"caption":"TeraByte Unlimited"},"image":{"@id":"https:\/\/www.terabyteunlimited.com\/nl\/#\/schema\/logo\/image\/"},"sameAs":["https:\/\/www.facebook.com\/terabyteunlimited"]}]}},"_links":{"self":[{"href":"https:\/\/www.terabyteunlimited.com\/nl\/wp-json\/wp\/v2\/pages\/45991","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.terabyteunlimited.com\/nl\/wp-json\/wp\/v2\/pages"}],"about":[{"href":"https:\/\/www.terabyteunlimited.com\/nl\/wp-json\/wp\/v2\/types\/page"}],"author":[{"embeddable":true,"href":"https:\/\/www.terabyteunlimited.com\/nl\/wp-json\/wp\/v2\/users\/4"}],"replies":[{"embeddable":true,"href":"https:\/\/www.terabyteunlimited.com\/nl\/wp-json\/wp\/v2\/comments?post=45991"}],"version-history":[{"count":2,"href":"https:\/\/www.terabyteunlimited.com\/nl\/wp-json\/wp\/v2\/pages\/45991\/revisions"}],"predecessor-version":[{"id":45993,"href":"https:\/\/www.terabyteunlimited.com\/nl\/wp-json\/wp\/v2\/pages\/45991\/revisions\/45993"}],"up":[{"embeddable":true,"href":"https:\/\/www.terabyteunlimited.com\/nl\/wp-json\/wp\/v2\/pages\/45765"}],"wp:attachment":[{"href":"https:\/\/www.terabyteunlimited.com\/nl\/wp-json\/wp\/v2\/media?parent=45991"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}