Every published environment is served as one JavaScript file with the container inlined. This is the same file your site loads, so it is exactly what is live.

1. Open your property in the Tags UI

   Go to experience.adobe.com → Data Collection → Tags, then select your property.

2. Open Environments

   Pick Environments in the left nav. You'll see Development, Staging and Production.

3. Open the install dialog

   Click the install icon </> on the row for the environment you want to audit. A dialog shows the embed code.

4. Copy the library URL out of the embed code

   It looks like this:

   https://assets.adobedtm.com/<hash>/<hash>/launch-<id>-development.min.js

5. Download it

   Either open the URL in a new tab and save the page, or:

   Copy

   curl -o container.js "https://assets.adobedtm.com/.../launch-....min.js"

6. Drop container.js into the box above

   Minified builds are fine — the container is found and read inside them.

If Tags is deployed on a site you can visit, the library is already public. This is the quickest way to audit a production property when you only have access to the website.

1. Open the site with Tags deployed

   Then open DevTools — F12, or Cmd+Option+I on a Mac.

2. Go to the Network tab and reload

   The library is requested early in page load.

3. Filter for the library

   Type assets.adobedtm.com in the filter box — or your own domain if the library is self-hosted. Look for launch-*.js.

4. Save the response

   Right-click the request → Save as… (or open the Response tab and copy it into a file).

5. Drop the file above

   Or paste the response straight into the Paste it tab — no file needed.

Reads the live _satellite.container and saves it as a file. Handy when the library is self-hosted at a URL you can't easily find, or sits behind authentication.

1. Open the site with Tags deployed, then the Console tab

   In Chrome you must type allow pasting once before it will accept pasted code.

2. Paste this and press Enter

   Copy snippet

   (function(){
     if(!window._satellite||!_satellite.container){
       console.error('No Adobe Tags container on this page.');return;
     }
     var stack=[],fns=0,cut=0;
     var json=JSON.stringify(_satellite.container,function(k,v){
       // Functions hold your custom code. JSON.stringify drops them silently,
       // so convert each one to source text before it is lost.
       if(typeof v==='function'){fns++;return Function.prototype.toString.call(v);}
       if(v instanceof RegExp){return String(v);}
       if(v&&typeof v==='object'){
         // Only a value that contains ITSELF is a cycle. Tracking every object
         // ever seen would also discard the second copy of a SHARED object, and
         // a live container shares plenty — that silently shrinks the export.
         while(stack.length&&stack[stack.length-1]!==this){stack.pop();}
         if(stack.indexOf(v)!==-1){cut++;return'[circular]';}
         stack.push(v);
       }
       return v;
     },2);
     var name=((_satellite.container.property||{}).name||'adobe-tags')
       .replace(/[^\w.-]+/g,'-').slice(0,60);
     var a=document.createElement('a');
     a.href=URL.createObjectURL(new Blob([
       'window._satellite = window._satellite || {};\n'+
       'window._satellite.container = '+json+';\n'
     ],{type:'text/javascript'}));
     a.download=name+'-container.js';
     document.body.appendChild(a);a.click();document.body.removeChild(a);
     // Compare these against the report. Silent shrinkage is the failure that
     // matters here: a smaller container scores better than the real one.
     console.log('Saved '+a.download+' — '+(_satellite.container.rules||[]).length+' rules, '+
       Object.keys(_satellite.container.dataElements||{}).length+' data elements, '+
       fns+' code blocks, '+json.length+' chars.');
     if(cut){console.warn('[Tags export] '+cut+' self-referencing object(s) collapsed.');}
   })();

3. A container.js downloads — drop it above

Why not just JSON.stringify(_satellite.container)? Because JSON.stringify drops functions silently — you would lose every custom code block and never be told. The snippet converts them to source text first. It also only collapses objects that genuinely contain themselves: a live container reaches the same settings object by more than one path, and discarding the second copy would quietly shrink the export — and inflate its score. If a container you export here scores better than the same property's container.js file, that gap is the thing to look at.

A runtime container only holds what was built into one environment — disabled rules are not in it at all. The Reactor API returns the whole property, including disabled rules, revision numbers and modified dates.

1. Create API credentials

   In the Adobe Developer Console, create a project and add the Adobe Experience Platform Launch API, using OAuth Server-to-Server. You'll get a client ID, a client secret and your org ID.

2. Set up your request headers

   Copy

   BASE=https://reactor.adobe.io
   AUTH=(-H "Authorization: Bearer $TOKEN"
         -H "x-api-key: $CLIENT_ID"
         -H "x-gw-ims-org-id: $ORG_ID"
         -H "Accept: application/vnd.api+json;revision=1")

3. Fetch the property's objects

   Copy

   curl -s "${AUTH[@]}" "$BASE/properties/$PROPERTY_ID/rules?page[size]=100"         > rules.json
   curl -s "${AUTH[@]}" "$BASE/properties/$PROPERTY_ID/data_elements?page[size]=100" > data_elements.json
   curl -s "${AUTH[@]}" "$BASE/properties/$PROPERTY_ID/extensions?page[size]=100"    > extensions.json
   
   # rule_components hang off each rule
   curl -s "${AUTH[@]}" "$BASE/rules/$RULE_ID/rule_components?page[size]=100"        > components-$RULE_ID.json

   Watch page[size] — the API paginates, so follow links.next if you have more than 100 of anything.

4. Drop all the files in at once

   Select every JSON file together and this app merges them for you — duplicates across files are removed. If you'd rather merge them yourself:

   Copy

   jq -s '{data: (map(.data) | add)}' rules.json data_elements.json \
      extensions.json components-*.json > property-export.json

If an environment is configured to self-host — SFTP or your own CDN rather than Adobe's — the built library is offered as a downloadable archive.

1. Open the environment in the Tags UI

   Data Collection → Tags → your property → Environments, then open the self-hosted environment.

2. Download the library archive

   The environment offers the built library as an archive once a library has been published to it.

3. Unzip it and find launch-*.js

   That file is the container build. Drop it above.

Already deploying self-hosted files through your own pipeline? The same launch-*.js that lands on your CDN works — no need to re-download it from Adobe.