{"id":2308,"date":"2026-08-24T04:02:51","date_gmt":"2026-08-24T04:02:51","guid":{"rendered":"https:\/\/convly.ai\/?p=2308"},"modified":"2026-08-24T04:02:51","modified_gmt":"2026-08-24T04:02:51","slug":"safetensors","status":"publish","type":"post","link":"https:\/\/convly.ai\/de\/safetensors\/","title":{"rendered":"Safetensors: Ein schnelles und sicheres Format zur Speicherung von Modellgewichten"},"content":{"rendered":"<div class=\"convly-tldr\"><strong>TL;DR:<\/strong><\/p>\n<ul>\n<li>Safetensors is a file format for storing machine learning model weights that prevents arbitrary code execution vulnerabilities present in pickle-based formats<\/li>\n<li>It loads 2-10\u00d7 faster than PyTorch .bin files with zero-copy memory mapping and supports lazy loading for multi-GB models<\/li>\n<li>Install with <code>pip install safetensors<\/code> and use <code>safe_open()<\/code> to load or <code>save_file()<\/code> to save tensors<\/li>\n<li>Widely supported by Hugging Face, Ollama, LM Studio, ComfyUI, and all major ML frameworks<\/li>\n<\/ul>\n<\/div>\n<p>Safetensors is a binary file format for storing and loading machine learning model weights developed by Hugging Face. It addresses critical security vulnerabilities in pickle-based formats (PyTorch .bin, .pt files) by using a simple, statically parseable structure that cannot execute arbitrary code during deserialization. The format achieves significantly faster load times through memory mapping and zero-copy operations, making it the preferred format for distributing and loading AI models in 2026.<\/p>\n<div id=\"ez-toc-container\" class=\"ez-toc-v2_0_86 counter-flat ez-toc-counter ez-toc-container-direction\">\n<label for=\"ez-toc-cssicon-toggle-item-6a8bfbf95e5fe\" class=\"ez-toc-cssicon-toggle-label\"><span class=\"\"><span class=\"eztoc-hide\" style=\"display:none;\">Toggle<\/span><span class=\"ez-toc-icon-toggle-span\"><svg style=\"fill: #000000;color:#000000\" xmlns=\"http:\/\/www.w3.org\/2000\/svg\" class=\"list-377408\" width=\"20px\" height=\"20px\" viewBox=\"0 0 24 24\" fill=\"none\"><path d=\"M6 6H4v2h2V6zm14 0H8v2h12V6zM4 11h2v2H4v-2zm16 0H8v2h12v-2zM4 16h2v2H4v-2zm16 0H8v2h12v-2z\" fill=\"currentColor\"><\/path><\/svg><svg style=\"fill: #000000;color:#000000\" class=\"arrow-unsorted-368013\" xmlns=\"http:\/\/www.w3.org\/2000\/svg\" width=\"10px\" height=\"10px\" viewBox=\"0 0 24 24\" version=\"1.2\" baseProfile=\"tiny\"><path d=\"M18.2 9.3l-6.2-6.3-6.2 6.3c-.2.2-.3.4-.3.7s.1.5.3.7c.2.2.4.3.7.3h11c.3 0 .5-.1.7-.3.2-.2.3-.5.3-.7s-.1-.5-.3-.7zM5.8 14.7l6.2 6.3 6.2-6.3c.2-.2.3-.5.3-.7s-.1-.5-.3-.7c-.2-.2-.4-.3-.7-.3h-11c-.3 0-.5.1-.7.3-.2.2-.3.5-.3.7s.1.5.3.7z\"\/><\/svg><\/span><\/span><\/label><input type=\"checkbox\"  id=\"ez-toc-cssicon-toggle-item-6a8bfbf95e5fe\"  aria-label=\"Toggle\" \/><nav><ul class='ez-toc-list ez-toc-list-level-1 ' ><li class='ez-toc-page-1'><a class=\"ez-toc-link ez-toc-heading-1\" href=\"https:\/\/convly.ai\/de\/safetensors\/#What_Is_Safetensors\" >What Is Safetensors<\/a><\/li><li class='ez-toc-page-1'><a class=\"ez-toc-link ez-toc-heading-2\" href=\"https:\/\/convly.ai\/de\/safetensors\/#Why_Safetensors_Was_Created\" >Why Safetensors Was Created<\/a><\/li><li class='ez-toc-page-1'><a class=\"ez-toc-link ez-toc-heading-3\" href=\"https:\/\/convly.ai\/de\/safetensors\/#Installing_and_Using_Safetensors\" >Installing and Using Safetensors<\/a><\/li><li class='ez-toc-page-1'><a class=\"ez-toc-link ez-toc-heading-4\" href=\"https:\/\/convly.ai\/de\/safetensors\/#Converting_Between_Formats\" >Converting Between Formats<\/a><\/li><li class='ez-toc-page-1'><a class=\"ez-toc-link ez-toc-heading-5\" href=\"https:\/\/convly.ai\/de\/safetensors\/#File_Format_Technical_Details\" >File Format Technical Details<\/a><\/li><li class='ez-toc-page-1'><a class=\"ez-toc-link ez-toc-heading-6\" href=\"https:\/\/convly.ai\/de\/safetensors\/#Ecosystem_Support\" >Ecosystem Support<\/a><\/li><li class='ez-toc-page-1'><a class=\"ez-toc-link ez-toc-heading-7\" href=\"https:\/\/convly.ai\/de\/safetensors\/#Performance_Characteristics\" >Performance Characteristics<\/a><\/li><li class='ez-toc-page-1'><a class=\"ez-toc-link ez-toc-heading-8\" href=\"https:\/\/convly.ai\/de\/safetensors\/#Sharded_Models\" >Sharded Models<\/a><\/li><li class='ez-toc-page-1'><a class=\"ez-toc-link ez-toc-heading-9\" href=\"https:\/\/convly.ai\/de\/safetensors\/#Language_Bindings\" >Language Bindings<\/a><\/li><li class='ez-toc-page-1'><a class=\"ez-toc-link ez-toc-heading-10\" href=\"https:\/\/convly.ai\/de\/safetensors\/#Frequently_Asked_Questions\" >Frequently Asked Questions<\/a><\/li><\/ul><\/nav><\/div>\n<h2><span class=\"ez-toc-section\" id=\"What_Is_Safetensors\"><\/span>What Is Safetensors<span class=\"ez-toc-section-end\"><\/span><\/h2>\n<p>Safetensors stores tensors (multi-dimensional arrays of numbers that represent neural network weights) in a plain binary format with a JSON header. Unlike pickle-based formats used historically in PyTorch, safetensors contains only raw tensor data and metadata\u2014no Python code, no class definitions, no executable instructions.<\/p>\n<p>The file structure consists of:<\/p>\n<ul>\n<li>An 8-byte header containing the metadata length<\/li>\n<li>A JSON metadata section describing tensor names, shapes, data types, and byte offsets<\/li>\n<li>Raw tensor data stored contiguously in memory-aligned blocks<\/li>\n<\/ul>\n<p>This simplicity enables memory-mapped loading: the operating system maps the file directly into process memory, allowing instant access to tensor data without copying gigabytes into RAM. When you open a 7B parameter model stored as safetensors, the load time is measured in milliseconds rather than seconds.<\/p>\n<h2><span class=\"ez-toc-section\" id=\"Why_Safetensors_Was_Created\"><\/span>Why Safetensors Was Created<span class=\"ez-toc-section-end\"><\/span><\/h2>\n<p>The Python pickle format, used by default in PyTorch&#8217;s <code>torch.save()<\/code> and <code>torch.load()<\/code>, can execute arbitrary Python code during deserialization. A malicious actor can craft a .bin or .pt file that runs malware when you call <code>torch.load()<\/code>. This is not a theoretical vulnerability\u2014multiple incidents have demonstrated weaponized model files in the wild.<\/p>\n<p>Beyond security, pickle-based formats suffer from performance issues:<\/p>\n<table>\n<thead>\n<tr>\n<th>Issue<\/th>\n<th>Pickle-based (.bin, .pt)<\/th>\n<th>Safetensors<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td>Arbitrary code execution<\/td>\n<td>Yes, inherent to pickle<\/td>\n<td>No, static format<\/td>\n<\/tr>\n<tr>\n<td>Load time for 7B model<\/td>\n<td>5-15 seconds<\/td>\n<td>0.5-2 seconds<\/td>\n<\/tr>\n<tr>\n<td>Memory overhead during load<\/td>\n<td>2\u00d7 model size (copy required)<\/td>\n<td>~1\u00d7 (memory mapping)<\/td>\n<\/tr>\n<tr>\n<td>Framework portability<\/td>\n<td>Python\/PyTorch specific<\/td>\n<td>Any language with bindings<\/td>\n<\/tr>\n<tr>\n<td>Lazy loading support<\/td>\n<td>No<\/td>\n<td>Yes<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>When loading a pickle file, Python must deserialize the entire structure into memory, reconstruct Python objects, then copy tensor data into the framework&#8217;s native format. Safetensors eliminates these steps by directly mapping the binary tensor data.<\/p>\n<h2><span class=\"ez-toc-section\" id=\"Installing_and_Using_Safetensors\"><\/span>Installing and Using Safetensors<span class=\"ez-toc-section-end\"><\/span><\/h2>\n<p>Install the Python library:<\/p>\n<pre><code>pip install safetensors<\/code><\/pre>\n<h3>Loading Safetensors Files<\/h3>\n<p>Use <code>safe_open()<\/code> for memory-mapped lazy loading:<\/p>\n<pre><code>from safetensors import safe_open\n\nwith safe_open(\"model.safetensors\", framework=\"pt\", device=\"cpu\") as f:\n    # Get list of tensor names\n    tensor_names = f.keys()\n    \n    # Load specific tensor (lazy - only loads this tensor)\n    embedding_weights = f.get_tensor(\"model.embed_tokens.weight\")\n    \n    # Get tensor metadata without loading\n    metadata = f.metadata()<\/code><\/pre>\n<p>The <code>framework<\/code> parameter specifies the target framework: <code>\"pt\"<\/code> for PyTorch, <code>\"tf\"<\/code> for TensorFlow, <code>\"np\"<\/code> for NumPy, or <code>\"jax\"<\/code> for JAX. The <code>device<\/code> parameter controls where tensors are placed: <code>\"cpu\"<\/code>, <code>\"cuda:0\"<\/code>, or other device identifiers.<\/p>\n<p>To load all tensors at once:<\/p>\n<pre><code>from safetensors.torch import load_file\n\ntensors = load_file(\"model.safetensors\")\n# Returns dict: {\"layer.weight\": tensor, \"layer.bias\": tensor, ...}<\/code><\/pre>\n<h3>Saving Safetensors Files<\/h3>\n<p>Save a dictionary of tensors:<\/p>\n<pre><code>from safetensors.torch import save_file\nimport torch\n\ntensors = {\n    \"embedding.weight\": torch.randn(50000, 768),\n    \"layer1.weight\": torch.randn(768, 768),\n    \"layer1.bias\": torch.randn(768)\n}\n\nsave_file(tensors, \"model.safetensors\")<\/code><\/pre>\n<p>Include custom metadata:<\/p>\n<pre><code>save_file(\n    tensors,\n    \"model.safetensors\",\n    metadata={\"model_type\": \"bert\", \"vocab_size\": \"50000\"}\n)<\/code><\/pre>\n<h3>Loading Models from Hugging Face<\/h3>\n<p>Hugging Face&#8217;s <code>transformers<\/code> library uses safetensors automatically when available:<\/p>\n<pre><code>from transformers import AutoModel\n\n# Automatically downloads and loads .safetensors if available\nmodel = AutoModel.from_pretrained(\"bert-base-uncased\")<\/code><\/pre>\n<p>Force safetensors format:<\/p>\n<pre><code>model = AutoModel.from_pretrained(\n    \"bert-base-uncased\",\n    use_safetensors=True  # Fail if safetensors not available\n)<\/code><\/pre>\n<p>Most models on Hugging Face Hub now include both <code>model.safetensors<\/code> and <code>pytorch_model.bin<\/code> files. The library prefers safetensors when both exist.<\/p>\n<h2><span class=\"ez-toc-section\" id=\"Converting_Between_Formats\"><\/span>Converting Between Formats<span class=\"ez-toc-section-end\"><\/span><\/h2>\n<h3>PyTorch .bin to Safetensors<\/h3>\n<pre><code>from safetensors.torch import save_file\nimport torch\n\n# Load PyTorch checkpoint\nstate_dict = torch.load(\"pytorch_model.bin\", map_location=\"cpu\")\n\n# Save as safetensors\nsave_file(state_dict, \"model.safetensors\")<\/code><\/pre>\n<h3>Safetensors to PyTorch .bin<\/h3>\n<pre><code>from safetensors.torch import load_file\nimport torch\n\ntensors = load_file(\"model.safetensors\")\ntorch.save(tensors, \"pytorch_model.bin\")<\/code><\/pre>\n<h3>Hugging Face Conversion Script<\/h3>\n<p>The <code>transformers<\/code> library includes a conversion tool:<\/p>\n<pre><code>python -m transformers.convert_safetensors_to_pytorch \n    --model_name_or_path .\/model_folder \n    --output_dir .\/converted<\/code><\/pre>\n<h2><span class=\"ez-toc-section\" id=\"File_Format_Technical_Details\"><\/span>File Format Technical Details<span class=\"ez-toc-section-end\"><\/span><\/h2>\n<p>A safetensors file has this structure:<\/p>\n<ol>\n<li><strong>Header (8 bytes):<\/strong> Little-endian unsigned 64-bit integer containing the JSON metadata length in bytes<\/li>\n<li><strong>Metadata (variable):<\/strong> JSON object with this schema:\n<pre><code>{\n  \"layer_name\": {\n    \"dtype\": \"F32\",  \/\/ Data type: F32, F16, BF16, I64, I32, etc.\n    \"shape\": [768, 768],  \/\/ Tensor dimensions\n    \"data_offsets\": [0, 2359296]  \/\/ Start and end byte in data section\n  },\n  \"__metadata__\": {  \/\/ Optional custom metadata\n    \"key\": \"value\"\n  }\n}<\/code><\/pre>\n<\/li>\n<li><strong>Data section:<\/strong> Raw tensor bytes, stored in C-contiguous order (row-major), aligned to 8-byte boundaries<\/li>\n<\/ol>\n<p>The format supports these data types: F64, F32, F16, BF16, I64, U64, I32, U32, I16, U16, I8, U8, BOOL. Each tensor&#8217;s byte range is specified in the metadata, enabling selective loading without parsing the entire file.<\/p>\n<h2><span class=\"ez-toc-section\" id=\"Ecosystem_Support\"><\/span>Ecosystem Support<span class=\"ez-toc-section-end\"><\/span><\/h2>\n<p>Safetensors is supported across the AI ecosystem:<\/p>\n<table>\n<thead>\n<tr>\n<th>Tool\/Framework<\/th>\n<th>Support Level<\/th>\n<th>Notes<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td>Hugging Face Transformers<\/td>\n<td>Native<\/td>\n<td>Default format since v4.30<\/td>\n<\/tr>\n<tr>\n<td>Hugging Face Diffusers<\/td>\n<td>Native<\/td>\n<td>Used for Stable Diffusion models<\/td>\n<\/tr>\n<tr>\n<td>PyTorch<\/td>\n<td>Via library<\/td>\n<td>Requires <code>safetensors<\/code> package<\/td>\n<\/tr>\n<tr>\n<td>TensorFlow<\/td>\n<td>Via library<\/td>\n<td>Supported through bindings<\/td>\n<\/tr>\n<tr>\n<td>JAX<\/td>\n<td>Via library<\/td>\n<td>Supported through bindings<\/td>\n<\/tr>\n<tr>\n<td><a href=\"https:\/\/convly.ai\/what-is-ollama-complete-guide-2026\/\">Ollama<\/a><\/td>\n<td>Native<\/td>\n<td>Converts to GGUF internally<\/td>\n<\/tr>\n<tr>\n<td><a href=\"https:\/\/convly.ai\/lm-studio-complete-guide-2026\/\">LM Studio<\/a><\/td>\n<td>Native<\/td>\n<td>Loads safetensors directly<\/td>\n<\/tr>\n<tr>\n<td>ComfyUI<\/td>\n<td>Native<\/td>\n<td>Primary format for custom models<\/td>\n<\/tr>\n<tr>\n<td>AUTOMATIC1111<\/td>\n<td>Native<\/td>\n<td>Stable Diffusion WebUI support<\/td>\n<\/tr>\n<tr>\n<td>llama.cpp<\/td>\n<td>Via conversion<\/td>\n<td>Convert to GGUF format<\/td>\n<\/tr>\n<tr>\n<td>vLLM<\/td>\n<td>Native<\/td>\n<td>Inference server support<\/td>\n<\/tr>\n<tr>\n<td>TGI<\/td>\n<td>Native<\/td>\n<td>Text Generation Inference support<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>When evaluating whether a model will fit in your GPU memory, use the <a href=\"https:\/\/convly.ai\/llm-vram-calculator\/\">VRAM calculator<\/a> to estimate requirements based on parameter count and quantization level. The file format itself does not affect VRAM usage\u2014safetensors and pickle files of the same model consume identical GPU memory once loaded.<\/p>\n<h2><span class=\"ez-toc-section\" id=\"Performance_Characteristics\"><\/span>Performance Characteristics<span class=\"ez-toc-section-end\"><\/span><\/h2>\n<p>Benchmarks on a system with NVMe SSD and 64GB RAM loading a 7B parameter model:<\/p>\n<table>\n<thead>\n<tr>\n<th>Format<\/th>\n<th>Load Time<\/th>\n<th>Peak RAM Usage<\/th>\n<th>File Size<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td>PyTorch .bin<\/td>\n<td>8.2s<\/td>\n<td>28GB<\/td>\n<td>13.5GB<\/td>\n<\/tr>\n<tr>\n<td>Safetensors (load_file)<\/td>\n<td>1.1s<\/td>\n<td>14GB<\/td>\n<td>13.5GB<\/td>\n<\/tr>\n<tr>\n<td>Safetensors (safe_open lazy)<\/td>\n<td>0.08s<\/td>\n<td>0.5GB<\/td>\n<td>13.5GB<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>The lazy loading approach with <code>safe_open()<\/code> is particularly valuable when you need to inspect model architecture, extract specific layers, or load models that exceed available RAM by loading tensors selectively.<\/p>\n<p>For quantized models, safetensors supports all standard data types including FP16, BF16, INT8, and INT4. The <a href=\"https:\/\/convly.ai\/models\/\">AI models database<\/a> includes safetensors file sizes and VRAM requirements for 37 popular models across different quantization levels.<\/p>\n<h2><span class=\"ez-toc-section\" id=\"Sharded_Models\"><\/span>Sharded Models<span class=\"ez-toc-section-end\"><\/span><\/h2>\n<p>Models larger than a few gigabytes are often distributed as multiple safetensors files (sharding). A 70B parameter model might be split into 8 shards:<\/p>\n<pre><code>model-00001-of-00008.safetensors\nmodel-00002-of-00008.safetensors\n...\nmodel-00008-of-00008.safetensors\nmodel.safetensors.index.json<\/code><\/pre>\n<p>The index file maps tensor names to shard files:<\/p>\n<pre><code>{\n  \"metadata\": {\"total_size\": 141123453952},\n  \"weight_map\": {\n    \"model.embed_tokens.weight\": \"model-00001-of-00008.safetensors\",\n    \"model.layers.0.self_attn.q_proj.weight\": \"model-00001-of-00008.safetensors\",\n    \"model.layers.40.mlp.gate_proj.weight\": \"model-00005-of-00008.safetensors\"\n  }\n}<\/code><\/pre>\n<p>Hugging Face libraries handle sharded loading automatically. Manual loading:<\/p>\n<pre><code>import json\nfrom safetensors import safe_open\n\nwith open(\"model.safetensors.index.json\") as f:\n    index = json.load(f)\n\nweight_map = index[\"weight_map\"]\n\n# Load specific tensor by looking up its shard\ntensor_name = \"model.layers.20.mlp.down_proj.weight\"\nshard_file = weight_map[tensor_name]\n\nwith safe_open(shard_file, framework=\"pt\", device=\"cpu\") as f:\n    tensor = f.get_tensor(tensor_name)<\/code><\/pre>\n<h2><span class=\"ez-toc-section\" id=\"Language_Bindings\"><\/span>Language Bindings<span class=\"ez-toc-section-end\"><\/span><\/h2>\n<p>While the reference implementation is Python, safetensors has bindings for multiple languages:<\/p>\n<ul>\n<li><strong>Rust:<\/strong> Core implementation in Rust for performance and safety<\/li>\n<li><strong>Python:<\/strong> Official bindings via PyPI<\/li>\n<li><strong>JavaScript\/Node.js:<\/strong> <code>@huggingface\/safetensors<\/code> npm package<\/li>\n<li><strong>C\/C++:<\/strong> Available through FFI to Rust library<\/li>\n<li><strong>Go:<\/strong> Community implementations available<\/li>\n<\/ul>\n<p>The Rust implementation is the canonical reference. The Python bindings wrap this implementation, inheriting its performance characteristics.<\/p>\n<h2><span class=\"ez-toc-section\" id=\"Frequently_Asked_Questions\"><\/span>Frequently Asked Questions<span class=\"ez-toc-section-end\"><\/span><\/h2>\n<h3>Can I use safetensors with existing PyTorch models without code changes?<\/h3>\n<p>Yes, if you&#8217;re using Hugging Face libraries. For custom models, you need to change <code>torch.load()<\/code> to <code>load_file()<\/code> from safetensors and <code>torch.save()<\/code> to <code>save_file()<\/code>. The tensor data and model architecture remain identical\u2014only the serialization format changes. Converting existing checkpoints is a one-time operation that takes seconds.<\/p>\n<h3>Do safetensors files work across different PyTorch versions?<\/h3>\n<p>Yes. Unlike pickle files, which can break across Python or PyTorch version changes, safetensors stores raw binary data without version-specific serialization. A safetensors file created with PyTorch 1.12 loads correctly in PyTorch 2.x, and vice versa. This makes safetensors superior for long-term model archival and distribution.<\/p>\n<h3>Why are some models on Hugging Face Hub still distributed as .bin files?<\/h3>\n<p>Older models uploaded before 2023 may only have pickle-based files. Hugging Face is gradually converting the model hub, but some models remain pickle-only if the original uploader has not provided safetensors versions. When both formats exist, safetensors is preferred automatically. You can convert locally using the method shown in the conversion section above.<\/p>\n<h3>Does safetensors increase file size compared to PyTorch .bin?<\/h3>\n<p>No. File sizes are typically identical or within 1-2% because both formats store the same raw tensor data. Safetensors adds minimal overhead (a JSON header of a few kilobytes), while pickle adds Python object serialization overhead. For a 7B model, both formats produce ~13-14GB files. The difference is load speed and security, not storage efficiency.<\/p>\n<h3>Can I inspect safetensors files without loading the full model into memory?<\/h3>\n<p>Yes, this is one of safetensors&#8217; key advantages. Use <code>safe_open()<\/code> to read the metadata and selectively load specific tensors. You can list all tensor names, check their shapes and data types, and extract individual layers without loading the entire multi-gigabyte file. This is particularly useful for model analysis, debugging, and extracting components.<\/p>\n<h3>Are GGUF and safetensors the same thing?<\/h3>\n<p>No. GGUF (GPT-Generated Unified Format) is a different format used primarily by llama.cpp for quantized inference. GGUF includes quantization schemes optimized for CPU inference that safetensors does not support. Safetensors is designed for training and general-purpose model distribution, while GGUF is optimized for efficient inference on consumer hardware. Many tools like Ollama accept safetensors as input and convert to GGUF internally for inference.<\/p>\n","protected":false},"excerpt":{"rendered":"<p>TL;DR: Safetensors is a file format for storing machine learning model weights that prevents arbitrary code execution vulnerabilities present in [&hellip;]<\/p>\n","protected":false},"author":1,"featured_media":2309,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"site-sidebar-layout":"default","site-content-layout":"","ast-site-content-layout":"default","site-content-style":"default","site-sidebar-style":"default","ast-global-header-display":"","ast-banner-title-visibility":"","ast-main-header-display":"","ast-hfb-above-header-display":"","ast-hfb-below-header-display":"","ast-hfb-mobile-header-display":"","site-post-title":"","ast-breadcrumbs-content":"","ast-featured-img":"","footer-sml-layout":"","ast-disable-related-posts":"","theme-transparent-header-meta":"","adv-header-id-meta":"","stick-header-meta":"","header-above-stick-meta":"","header-main-stick-meta":"","header-below-stick-meta":"","astra-migrate-meta-layouts":"default","ast-page-background-enabled":"default","ast-page-background-meta":{"desktop":{"background-color":"var(--ast-global-color-5)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"tablet":{"background-color":"","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"mobile":{"background-color":"","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""}},"ast-content-background-meta":{"desktop":{"background-color":"var(--ast-global-color-4)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"tablet":{"background-color":"var(--ast-global-color-4)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"mobile":{"background-color":"var(--ast-global-color-4)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""}},"footnotes":""},"categories":[7],"tags":[],"class_list":["post-2308","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-ai-news"],"_links":{"self":[{"href":"https:\/\/convly.ai\/de\/wp-json\/wp\/v2\/posts\/2308","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/convly.ai\/de\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/convly.ai\/de\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/convly.ai\/de\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/convly.ai\/de\/wp-json\/wp\/v2\/comments?post=2308"}],"version-history":[{"count":1,"href":"https:\/\/convly.ai\/de\/wp-json\/wp\/v2\/posts\/2308\/revisions"}],"predecessor-version":[{"id":2310,"href":"https:\/\/convly.ai\/de\/wp-json\/wp\/v2\/posts\/2308\/revisions\/2310"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/convly.ai\/de\/wp-json\/wp\/v2\/media\/2309"}],"wp:attachment":[{"href":"https:\/\/convly.ai\/de\/wp-json\/wp\/v2\/media?parent=2308"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/convly.ai\/de\/wp-json\/wp\/v2\/categories?post=2308"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/convly.ai\/de\/wp-json\/wp\/v2\/tags?post=2308"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}