Create a gzipped tar archive containing multiple result files

{
  ":original": {
    "robot": "/upload/handle"
  },
  "resized": {
    "use": ":original",
    "robot": "/image/resize",
    "zoom": false,
    "width": 100,
    "height": 100,
    "imagemagick_stack": "v2.0.7"
  },
  "archived": {
    "use": {
      "steps": [
        ":original",
        "resized"
      ],
      "bundle_steps": true
    },
    "robot": "/file/compress",
    "result": true,
    "format": "tar",
    "gzip": true
  },
  "exported": {
    "use": [
      "resized",
      "archived",
      ":original"
    ],
    "robot": "/s3/store",
    "credentials": "YOUR_AWS_CREDENTIALS",
    "url_prefix": "https://demos.transloadit.com/"
  }
}

# Prerequisites: brew install curl jq || sudo apt install curl jq
# To avoid tampering, use Signature Authentication
echo '{
  "auth": {
    "key": "YOUR_TRANSLOADIT_KEY"
  },
  "steps":   {
    ":original": {
      "robot": "/upload/handle"
    },
    "resized": {
      "use": ":original",
      "robot": "/image/resize",
      "zoom": false,
      "width": 100,
      "height": 100,
      "imagemagick_stack": "v2.0.7"
    },
    "archived": {
      "use": {
        "steps": [
          ":original",
          "resized"
        ],
        "bundle_steps": true
      },
      "robot": "/file/compress",
      "result": true,
      "format": "tar",
      "gzip": true
    },
    "exported": {
      "use": [
        "resized",
        "archived",
        ":original"
      ],
      "robot": "/s3/store",
      "credentials": "YOUR_AWS_CREDENTIALS",
      "url_prefix": "https://demos.transloadit.com/"
    }
  }
}' |curl \\
    --request POST \\
    --form 'params=<-' \\
    --form my_file1=@./ben-o-sullivan-382817.jpg \\
    --form my_file2=@./anete-lusina-382336.jpg \\
  https://api2.transloadit.com/assemblies \\
|jq

// Add 'Transloadit' to your Podfile, run 'pod install', add credentials to 'Info.plist'
import Arcane
import TransloaditKit

// Set Encoding Instructions
var AssemblySteps: Array = Array<Step>() // An array to hold the Steps

var Step1 = Step (key: ":original") // Create a Step object
Step1?.setValue("/upload/handle", forOption: "robot") // Add the details
AssemblySteps.append(Step1) // Add the Step to the array

var Step2 = Step (key: "resized") // Create a Step object
Step2?.setValue(":original", forOption: "use") // Add the details
Step2?.setValue("/image/resize", forOption: "robot") // Add the details
Step2?.setValue(100, forOption: "height") // Add the details
Step2?.setValue("v2.0.7", forOption: "imagemagick_stack") // Add the details
Step2?.setValue(100, forOption: "width") // Add the details
Step2?.setValue(false, forOption: "zoom") // Add the details
AssemblySteps.append(Step2) // Add the Step to the array

var Step3 = Step (key: "archived") // Create a Step object
Step3?.setValue({"steps":[":original","resized"],"bundle_steps":true}, forOption: "use") // Add the details
Step3?.setValue("/file/compress", forOption: "robot") // Add the details
Step3?.setValue(true, forOption: "result") // Add the details
Step3?.setValue("tar", forOption: "format") // Add the details
Step3?.setValue(true, forOption: "gzip") // Add the details
AssemblySteps.append(Step3) // Add the Step to the array

var Step4 = Step (key: "exported") // Create a Step object
Step4?.setValue(["resized","archived",":original"], forOption: "use") // Add the details
Step4?.setValue("/s3/store", forOption: "robot") // Add the details
Step4?.setValue("YOUR_AWS_CREDENTIALS", forOption: "credentials") // Add the details
Step4?.setValue("https://demos.transloadit.com/", forOption: "url_prefix") // Add the details
AssemblySteps.append(Step4) // Add the Step to the array

// We then create an Assembly Object with the Steps and files
var MyAssembly: Assembly = Assembly(steps: AssemblySteps, andNumberOfFiles: 1)

// Add files to upload
MyAssembly.addFile("./ben-o-sullivan-382817.jpg")
MyAssembly.addFile("./anete-lusina-382336.jpg")

// Start the Assembly
Transloadit.createAssembly(MyAssembly) 

// Fires after your Assembly has completed
transloadit.assemblyStatusBlock = {(_ completionDictionary: [AnyHashable: Any]) -> Void in
  print("\(completionDictionary.description)")
}

<body>
  <form action="/uploads" enctype="multipart/form-data" method="POST">
    <input type="file" name="my_file" multiple="multiple" />
  </form>

  <script src="//ajax.googleapis.com/ajax/libs/jquery/3.2.0/jquery.min.js"></script>
  <script src="//assets.transloadit.com/js/jquery.transloadit2-v3-latest.js"></script>
  <script type="text/javascript">
  $(function() {
    $('form').transloadit({
      wait: true,
      triggerUploadOnFileSelection: true,
      params: {
        auth: {
          // To avoid tampering use signatures:
          // https://transloadit.com/docs/api/#authentication
          key: 'YOUR_TRANSLOADIT_KEY',
        },
        // It's often better store encoding instructions in your account
        // and use a `template_id` instead of adding these steps inline
        steps: {
          ':original': {
            robot: '/upload/handle'
          },
          resized: {
            use: ':original',
            robot: '/image/resize',
            height: 100,
            imagemagick_stack: 'v2.0.7',
            width: 100,
            zoom: false
          },
          archived: {
            use: {'steps':[':original','resized'],'bundle_steps':true},
            robot: '/file/compress',
            result: true,
            format: 'tar',
            gzip: true
          },
          exported: {
            use: ['resized','archived',':original'],
            robot: '/s3/store',
            credentials: 'YOUR_AWS_CREDENTIALS',
            url_prefix: 'https://demos.transloadit.com/'
          }
        }
      }
    });
  });
  </script>
</body>

// yarn add transloadit || npm i transloadit --save-exact
const Transloadit = require('transloadit')

const transloadit = new Transloadit({
  authKey: 'YOUR_TRANSLOADIT_KEY',
  authSecret: 'YOUR_TRANSLOADIT_SECRET'
})

// Set Encoding Instructions
const options = {
  files: {
    // Add files to upload
    'myfile_1': './ben-o-sullivan-382817.jpg',
    'myfile_2': './anete-lusina-382336.jpg',
  },
  params: {
    steps: {
      ':original': {
        robot: '/upload/handle',
      },
      resized: {
        use: ':original',
        robot: '/image/resize',
        height: 100,
        imagemagick_stack: 'v2.0.7',
        width: 100,
        zoom: false,
      },
      archived: {
        use: {'steps':[':original','resized'],'bundle_steps':true},
        robot: '/file/compress',
        result: true,
        format: 'tar',
        gzip: true,
      },
      exported: {
        use: ['resized','archived',':original'],
        robot: '/s3/store',
        credentials: 'YOUR_AWS_CREDENTIALS',
        url_prefix: 'https://demos.transloadit.com/',
      },
    }
  }
}
// Start the Assembly
const result = await transloadit.createAssembly(options)
console.log({ result })

[sudo] npm install transloadify -g

export TRANSLOADIT_KEY="YOUR_TRANSLOADIT_KEY"
export TRANSLOADIT_SECRET="YOUR_TRANSLOADIT_SECRET"

# Save Encoding Instructions
echo '{
  ":original": {
    "robot": "/upload/handle"
  },
  "resized": {
    "use": ":original",
    "robot": "/image/resize",
    "zoom": false,
    "width": 100,
    "height": 100,
    "imagemagick_stack": "v2.0.7"
  },
  "archived": {
    "use": {
      "steps": [
        ":original",
        "resized"
      ],
      "bundle_steps": true
    },
    "robot": "/file/compress",
    "result": true,
    "format": "tar",
    "gzip": true
  },
  "exported": {
    "use": [
      "resized",
      "archived",
      ":original"
    ],
    "robot": "/s3/store",
    "credentials": "YOUR_AWS_CREDENTIALS",
    "url_prefix": "https://demos.transloadit.com/"
  }
}' > ./steps.json

transloadify \
  --input "./ben-o-sullivan-382817.jpg" \
  --input "./anete-lusina-382336.jpg" \
  --output "./output.example" \
  --steps "./steps.json"  

// composer require transloadit/php-sdk
use transloadit\Transloadit;
$transloadit = new Transloadit([
  "key" => "YOUR_TRANSLOADIT_KEY",
  "secret" => "YOUR_TRANSLOADIT_SECRET",
]);

// Add files to upload
$files = [];
array_push($files, "./ben-o-sullivan-382817.jpg")
array_push($files, "./anete-lusina-382336.jpg")

// Start the Assembly
$response = $transloadit->createAssembly([
  "files" => $files, 
  "params" => [
    "steps" => [
      ":original" => [
        "robot" => "/upload/handle",
      ],
      "resized" => [
        "use" => ":original",
        "robot" => "/image/resize",
        "height" => 100,
        "imagemagick_stack" => "v2.0.7",
        "width" => 100,
        "zoom" => false,
      ],
      "archived" => [
        "use" => [
          "steps" => [":original", "resized"],
          "bundle_steps" => true,
        ],
        "robot" => "/file/compress",
        "result" => true,
        "format" => "tar",
        "gzip" => true,
      ],
      "exported" => [
        "use" => ["resized", "archived", ":original"],
        "robot" => "/s3/store",
        "credentials" => "YOUR_AWS_CREDENTIALS",
        "url_prefix" => "https://demos.transloadit.com/",
      ],
    ],
  ],
]);

# gem install transloadit
transloadit = Transloadit.new(
  :key => "YOUR_TRANSLOADIT_KEY",
  :secret => "YOUR_TRANSLOADIT_SECRET"
)

# Set Encoding Instructions
:original = transloadit.step ":original", "/upload/handle",
)
resized = transloadit.step "resized", "/image/resize",
  :use => ":original",
  :height => 100,
  :imagemagick_stack => "v2.0.7",
  :width => 100,
  :zoom => false
)
archived = transloadit.step "archived", "/file/compress",
  :use => {"steps":[":original","resized"],"bundle_steps":true},
  :result => true,
  :format => "tar",
  :gzip => true
)
exported = transloadit.step "exported", "/s3/store",
  :use => ["resized","archived",":original"],
  :credentials => "YOUR_AWS_CREDENTIALS",
  :url_prefix => "https://demos.transloadit.com/"
)

assembly = transloadit.assembly(
  :steps => [ :original, resized, archived, exported ]
)

# Add files to upload
files = []
files.push("./ben-o-sullivan-382817.jpg")
files.push("./anete-lusina-382336.jpg")

# Start the Assembly
response = assembly.create! *files

until response.finished?
  sleep 1; response.reload!
end

if !response.error?
  # handle success
end

# pip install pytransloadit
from transloadit import client

tl = client.Transloadit('YOUR_TRANSLOADIT_KEY', 'YOUR_TRANSLOADIT_SECRET')
assembly = tl.new_assembly()

# Set Encoding Instructions
assembly.add_step(':original', '/upload/handle', {})
assembly.add_step('resized', '/image/resize', {
  'use': ':original',
  'height': 100,
  'imagemagick_stack': 'v2.0.7',
  'width': 100,
  'zoom': False
})
assembly.add_step('archived', '/file/compress', {
  'use': {'steps':[':original','resized'],'bundle_steps':True},
  'result': True,
  'format': 'tar',
  'gzip': True
})
assembly.add_step('exported', '/s3/store', {
  'use': ['resized','archived',':original'],
  'credentials': 'YOUR_AWS_CREDENTIALS',
  'url_prefix': 'https://demos.transloadit.com/'
})

# Add files to upload
assembly.add_file(open('./ben-o-sullivan-382817.jpg', 'rb'))
assembly.add_file(open('./anete-lusina-382336.jpg', 'rb'))

# Start the Assembly
assembly_response = assembly.create(retries=5, wait=True)

print(assembly_response.data.get('assembly_ssl_url'))
# or:
print(assembly_response.data['assembly_ssl_url'])

// go get gopkg.in/transloadit/go-sdk.v1
package main

import (
	"fmt"

	"gopkg.in/transloadit/go-sdk.v1"
)

options := transloadit.DefaultConfig
options.AuthKey = "YOUR_TRANSLOADIT_KEY"
options.AuthSecret = "YOUR_TRANSLOADIT_SECRET"
client := transloadit.NewClient(options)

// Initialize new Assembly
assembly := transloadit.NewAssembly()

// Set Encoding Instructions
assembly.AddStep(":original", map[string]interface{}{
  "robot": "/upload/handle"
})
assembly.AddStep("resized", map[string]interface{}{
  "use": ":original",
  "robot": "/image/resize",
  "height": 100,
  "imagemagick_stack": "v2.0.7",
  "width": 100,
  "zoom": false
})
assembly.AddStep("archived", map[string]interface{}{
  "use": {"steps":[":original", "resized"],"bundle_steps":true},
  "robot": "/file/compress",
  "result": true,
  "format": "tar",
  "gzip": true
})
assembly.AddStep("exported", map[string]interface{}{
  "use": ["resized", "archived", ":original"],
  "robot": "/s3/store",
  "credentials": "YOUR_AWS_CREDENTIALS",
  "url_prefix": "https://demos.transloadit.com/"
})

// Add files to upload
assembly.AddFile("myfile_1", "./ben-o-sullivan-382817.jpg")
assembly.AddFile("myfile_2", "./anete-lusina-382336.jpg")

// Start the Assembly
info, err := client.StartAssembly(context.Background(), assembly)
if err != nil {
  panic(err)
}

// All files have now been uploaded and the Assembly has started but no
// results are available yet since the conversion has not finished.
// WaitForAssembly provides functionality for polling until the Assembly
// has ended.
info, err = client.WaitForAssembly(context.Background(), info)
if err != nil {
  panic(err)
}

fmt.Printf("You can check some results at: \n")
fmt.Printf("  - %s\n", info.Results[":original"][0].SSLURL)
fmt.Printf("  - %s\n", info.Results["resized"][0].SSLURL)
fmt.Printf("  - %s\n", info.Results["archived"][0].SSLURL)
fmt.Printf("  - %s\n", info.Results["exported"][0].SSLURL)

// compile 'com.transloadit.sdk:transloadit:0.1.5'
import com.transloadit.sdk.Assembly;
import com.transloadit.sdk.Transloadit;
import com.transloadit.sdk.exceptions.LocalOperationException;
import com.transloadit.sdk.exceptions.RequestException;
import com.transloadit.sdk.response.AssemblyResponse;

import java.io.File;
import java.util.HashMap;
import java.util.Map;

public class Main {
  public static void main(String[] args) {
    Transloadit transloadit = new Transloadit("YOUR_TRANSLOADIT_KEY", "YOUR_TRANSLOADIT_SECRET");
    Assembly assembly = transloadit.newAssembly();
    // Set Encoding Instructions
    Map<String Object> :originalStepOptions = new HashMap();
  
    assembly.addStep(":original", "/upload/handle", :originalStepOptions);

    Map<String Object> resizedStepOptions = new HashMap();
    resizedStepOptions.put("use", ":original");
    resizedStepOptions.put("height", 100);
    resizedStepOptions.put("imagemagick_stack", "v2.0.7");
    resizedStepOptions.put("width", 100);
    resizedStepOptions.put("zoom", false);
    assembly.addStep("resized", "/image/resize", resizedStepOptions);

    Map<String Object> archivedStepOptions = new HashMap();
    archivedStepOptions.put("use", new HashMap(){{
          put("steps", new HashMap(){{
          put("0", ":original");
        put("1", "resized");
      }});
        put("bundle_steps", true);
      }});
    archivedStepOptions.put("result", true);
    archivedStepOptions.put("format", "tar");
    archivedStepOptions.put("gzip", true);
    assembly.addStep("archived", "/file/compress", archivedStepOptions);

    Map<String Object> exportedStepOptions = new HashMap();
    exportedStepOptions.put("use", new HashMap(){{
          put("0", "resized");
        put("1", "archived");
        put("2", ":original");
      }});
    exportedStepOptions.put("credentials", "YOUR_AWS_CREDENTIALS");
    exportedStepOptions.put("url_prefix", "https://demos.transloadit.com/");
    assembly.addStep("exported", "/s3/store", exportedStepOptions);

    // Add files to upload
    assembly.addFile(new File("./ben-o-sullivan-382817.jpg"));
    assembly.addFile(new File("./anete-lusina-382336.jpg"));
    
    // Start the Assembly
    try {
      AssemblyResponse response = assembly.save();
      
      // Wait for Assembly to finish executing
      while (!response.isFinished()) {
        response = transloadit.getAssemblyByUrl(response.getSslUrl());
      }
      
      System.out.println(response.getId());
      System.out.println(response.getUrl());
      System.out.println(response.json());
    } catch (RequestException | LocalOperationException e) {
      // Handle exception here
    }
  }
}