Only resize larger images when resizing files

{
  "steps": {
    ":original": {
      "robot": "/upload/handle"
    },
    "large_filtered": {
      "use": ":original",
      "robot": "/file/filter",
      "result": true,
      "accepts": [["${file.meta.width}", ">", "2048"], ["${file.meta.height}", ">", "2048"]],
      "condition_type": "or"
    },
    "smaller_filtered": {
      "use": ":original",
      "robot": "/file/filter",
      "result": true,
      "accepts": [["${file.meta.width}", "<=", "2048"], ["${file.meta.height}", "<=", "2048"]],
      "condition_type": "or"
    },
    "large_resized": {
      "use": "large_filtered",
      "robot": "/image/resize",
      "result": true,
      "resize_strategy": "fit",
      "width": 2048,
      "height": 2048,
      "imagemagick_stack": "v3.0.0"
    },
    "smaller_resized": {
      "use": "smaller_filtered",
      "robot": "/image/resize",
      "result": true,
      "resize_strategy": "fit",
      "width": "${file.meta.width}",
      "height": "${file.meta.height}",
      "imagemagick_stack": "v3.0.0"
    },
    "optimized": {
      "result": true,
      "use": ["smaller_resized", "large_resized"],
      "robot": "/image/optimize"
    },
    "exported": {
      "use": [":original", "large_filtered", "large_resized", "optimized", "smaller_filtered", "smaller_resized"],
      "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 '{
  "template_id": undefined,
  "auth": {
    "key": "YOUR_TRANSLOADIT_KEY"
  },
  "steps": {
    ":original": {
      "robot": "/upload/handle"
    },
    "large_filtered": {
      "use": ":original",
      "robot": "/file/filter",
      "result": true,
      "accepts": [["${file.meta.width}", ">", "2048"], ["${file.meta.height}", ">", "2048"]],
      "condition_type": "or"
    },
    "smaller_filtered": {
      "use": ":original",
      "robot": "/file/filter",
      "result": true,
      "accepts": [["${file.meta.width}", "<=", "2048"], ["${file.meta.height}", "<=", "2048"]],
      "condition_type": "or"
    },
    "large_resized": {
      "use": "large_filtered",
      "robot": "/image/resize",
      "result": true,
      "resize_strategy": "fit",
      "width": 2048,
      "height": 2048,
      "imagemagick_stack": "v3.0.0"
    },
    "smaller_resized": {
      "use": "smaller_filtered",
      "robot": "/image/resize",
      "result": true,
      "resize_strategy": "fit",
      "width": "${file.meta.width}",
      "height": "${file.meta.height}",
      "imagemagick_stack": "v3.0.0"
    },
    "optimized": {
      "result": true,
      "use": ["smaller_resized", "large_resized"],
      "robot": "/image/optimize"
    },
    "exported": {
      "use": [":original", "large_filtered", "large_resized", "optimized", "smaller_filtered", "smaller_resized"],
      "robot": "/s3/store",
      "credentials": "YOUR_AWS_CREDENTIALS",
      "url_prefix": "https://demos.transloadit.com/"
    }
  }
}' |curl \
    --request POST \
    --form 'params=<-' \
    --form myfile1=@./chameleon-small.jpg \
    --form myfile2=@./damselfly.jpg \
    --form myfile3=@./patrick-tomasso-60176.jpg \
  https://api2.transloadit.com/assemblies \
|jq

// Install via Swift Package Manager:
// dependencies: [
//   .package(url: "https://github.com/transloadit/TransloaditKit", .upToNextMajor(from: "3.0.0"))
// ]

// Or via CocoaPods:
// pod 'Transloadit', '~> 3.0.0'

// Auth
let credentials = Credentials(key: "YOUR_TRANSLOADIT_KEY")

// Init
let transloadit = Transloadit(credentials: credentials, session: "URLSession.shared")

// Add files to upload
let filesToUpload: [URL] = ...

// Execute
let assembly = transloadit.assembly(steps: [
  _originalStep, 
,  large_filteredStep, 
,  smaller_filteredStep, 
,  large_resizedStep, 
,  smaller_resizedStep, 
,  optimizedStep, 
,  exportedStep, 
], andUpload: filesToUpload) { result in
  switch result {
  case .success(let assembly):
    print("Retrieved (assembly)")
  case .failure(let error):
    print("Assembly error (error)")
  }
}.pollAssemblyStatus { result in
  switch result {
  case .success(let assemblyStatus):
    print("Received assemblystatus (assemblyStatus)")
  case .failure(let error):
    print("Caught polling error (error)")
  }

<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,
        // To avoid tampering, use Signature Authentication:
        // https://transloadit.com/docs/topics/signature-authentication/
        auth: {
          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',
          },
          large_filtered: {
            use: ':original',
            robot: '/file/filter',
            result: true,
            accepts: [['${file.meta.width}', '>', '2048'], ['${file.meta.height}', '>', '2048']],
            condition_type: 'or',
          },
          smaller_filtered: {
            use: ':original',
            robot: '/file/filter',
            result: true,
            accepts: [['${file.meta.width}', '<=', '2048'], ['${file.meta.height}', '<=', '2048']],
            condition_type: 'or',
          },
          large_resized: {
            use: 'large_filtered',
            robot: '/image/resize',
            result: true,
            resize_strategy: 'fit',
            width: 2048,
            height: 2048,
            imagemagick_stack: 'v3.0.0',
          },
          smaller_resized: {
            use: 'smaller_filtered',
            robot: '/image/resize',
            result: true,
            resize_strategy: 'fit',
            width: '${file.meta.width}',
            height: '${file.meta.height}',
            imagemagick_stack: 'v3.0.0',
          },
          optimized: {
            result: true,
            use: ['smaller_resized', 'large_resized'],
            robot: '/image/optimize',
          },
          exported: {
            use: [':original', 'large_filtered', 'large_resized', 'optimized', 'smaller_filtered', 'smaller_resized'],
            robot: '/s3/store',
            credentials: 'YOUR_AWS_CREDENTIALS',
            url_prefix: 'https://demos.transloadit.com/',
          },
        },
      })
    })
  </script>
</body>

// yarn add transloadit || npm i transloadit

// Import
const Transloadit = require('transloadit')

// Init
const transloadit = new Transloadit({
  authKey: 'YOUR_TRANSLOADIT_KEY',
  authSecret: 'MY_TRANSLOADIT_SECRET',
})

// Set Encoding Instructions
const options = {
  files: {
    myfile_1: './chameleon-small.jpg',
    myfile_2: './damselfly.jpg',
    myfile_3: './patrick-tomasso-60176.jpg',
  },
  params: {
    steps: {
      ':original': {
        robot: '/upload/handle',
      },
      large_filtered: {
        use: ':original',
        robot: '/file/filter',
        result: true,
        accepts: [['${file.meta.width}', '>', '2048'], ['${file.meta.height}', '>', '2048']],
        condition_type: 'or',
      },
      smaller_filtered: {
        use: ':original',
        robot: '/file/filter',
        result: true,
        accepts: [['${file.meta.width}', '<=', '2048'], ['${file.meta.height}', '<=', '2048']],
        condition_type: 'or',
      },
      large_resized: {
        use: 'large_filtered',
        robot: '/image/resize',
        result: true,
        resize_strategy: 'fit',
        width: 2048,
        height: 2048,
        imagemagick_stack: 'v3.0.0',
      },
      smaller_resized: {
        use: 'smaller_filtered',
        robot: '/image/resize',
        result: true,
        resize_strategy: 'fit',
        width: '${file.meta.width}',
        height: '${file.meta.height}',
        imagemagick_stack: 'v3.0.0',
      },
      optimized: {
        result: true,
        use: ['smaller_resized', 'large_resized'],
        robot: '/image/optimize',
      },
      exported: {
        use: [':original', 'large_filtered', 'large_resized', 'optimized', 'smaller_filtered', 'smaller_resized'],
        robot: '/s3/store',
        credentials: 'YOUR_AWS_CREDENTIALS',
        url_prefix: 'https://demos.transloadit.com/',
      },
    },
  },
}

// Execute
const result = await transloadit.createAssembly(options)

// Show results
console.log({ result })

# [sudo] npm install transloadify -g

# Auth
export TRANSLOADIT_KEY="YOUR_TRANSLOADIT_KEY"

# Save Encoding Instructions
echo '{
  "steps": {
    ":original": {
      "robot": "/upload/handle"
    },
    "large_filtered": {
      "use": ":original",
      "robot": "/file/filter",
      "result": true,
      "accepts": [["${file.meta.width}", ">", "2048"], ["${file.meta.height}", ">", "2048"]],
      "condition_type": "or"
    },
    "smaller_filtered": {
      "use": ":original",
      "robot": "/file/filter",
      "result": true,
      "accepts": [["${file.meta.width}", "<=", "2048"], ["${file.meta.height}", "<=", "2048"]],
      "condition_type": "or"
    },
    "large_resized": {
      "use": "large_filtered",
      "robot": "/image/resize",
      "result": true,
      "resize_strategy": "fit",
      "width": 2048,
      "height": 2048,
      "imagemagick_stack": "v3.0.0"
    },
    "smaller_resized": {
      "use": "smaller_filtered",
      "robot": "/image/resize",
      "result": true,
      "resize_strategy": "fit",
      "width": "${file.meta.width}",
      "height": "${file.meta.height}",
      "imagemagick_stack": "v3.0.0"
    },
    "optimized": {
      "result": true,
      "use": ["smaller_resized", "large_resized"],
      "robot": "/image/optimize"
    },
    "exported": {
      "use": [":original", "large_filtered", "large_resized", "optimized", "smaller_filtered", "smaller_resized"],
      "robot": "/s3/store",
      "credentials": "YOUR_AWS_CREDENTIALS",
      "url_prefix": "https://demos.transloadit.com/"
    }
  }
}' > ./steps.json

# Execute
transloadify \
  --input "chameleon-small.jpg" \
  --input "damselfly.jpg" \
  --input "patrick-tomasso-60176.jpg" \
  --steps "./steps.json" \
  --output "./output.example"

// composer require transloadit/php-sdk
use transloadit\Transloadit;

$transloadit = new Transloadit([
  "key" => "YOUR_TRANSLOADIT_KEY",
  "secret" => "MY_TRANSLOADIT_SECRET",
]);

// Start the Assembly
$response = $transloadit->createAssembly([
  "files" => ["chameleon-small.jpg", "damselfly.jpg", "patrick-tomasso-60176.jpg"],
  "params" => [
    "steps" => [
      ":original" => [
        "robot" => "/upload/handle",
      ],
      "large_filtered" => [
        "use" => ":original",
        "robot" => "/file/filter",
        "result" => true,
        "accepts" => [["${file.meta.width}", ">", "2048"], ["${file.meta.height}", ">", "2048"]],
        "condition_type" => "or",
      ],
      "smaller_filtered" => [
        "use" => ":original",
        "robot" => "/file/filter",
        "result" => true,
        "accepts" => [["${file.meta.width}", "<=", "2048"], ["${file.meta.height}", "<=", "2048"]],
        "condition_type" => "or",
      ],
      "large_resized" => [
        "use" => "large_filtered",
        "robot" => "/image/resize",
        "result" => true,
        "resize_strategy" => "fit",
        "width" => 2048,
        "height" => 2048,
        "imagemagick_stack" => "v3.0.0",
      ],
      "smaller_resized" => [
        "use" => "smaller_filtered",
        "robot" => "/image/resize",
        "result" => true,
        "resize_strategy" => "fit",
        "width" => "${file.meta.width}",
        "height" => "${file.meta.height}",
        "imagemagick_stack" => "v3.0.0",
      ],
      "optimized" => [
        "result" => true,
        "use" => ["smaller_resized", "large_resized"],
        "robot" => "/image/optimize",
      ],
      "exported" => [
        "use" => [":original", "large_filtered", "large_resized", "optimized", "smaller_filtered", "smaller_resized"],
        "robot" => "/s3/store",
        "credentials" => "YOUR_AWS_CREDENTIALS",
        "url_prefix" => "https://demos.transloadit.com/",
      ],
    ],
  ],
]);

# gem install transloadit

# $ irb -rubygems
# >> require 'transloadit'
# => true

transloadit = Transloadit.new([
  :key => "YOUR_TRANSLOADIT_KEY",
])

# Set Encoding Instructions
_original = transloadit.step(":original", "/upload/handle", {})

large_filtered = transloadit.step("large_filtered", "/file/filter", [
  :use => ":original",
  :result => true,
  :accepts => [["${file.meta.width}", ">", "2048"], ["${file.meta.height}", ">", "2048"]],
  :condition_type => "or"
])

smaller_filtered = transloadit.step("smaller_filtered", "/file/filter", [
  :use => ":original",
  :result => true,
  :accepts => [["${file.meta.width}", "<=", "2048"], ["${file.meta.height}", "<=", "2048"]],
  :condition_type => "or"
])

large_resized = transloadit.step("large_resized", "/image/resize", [
  :use => "large_filtered",
  :result => true,
  :resize_strategy => "fit",
  :width => 2048,
  :height => 2048,
  :imagemagick_stack => "v3.0.0"
])

smaller_resized = transloadit.step("smaller_resized", "/image/resize", [
  :use => "smaller_filtered",
  :result => true,
  :resize_strategy => "fit",
  :width => "${file.meta.width}",
  :height => "${file.meta.height}",
  :imagemagick_stack => "v3.0.0"
])

optimized = transloadit.step("optimized", "/image/optimize", [
  :result => true,
  :use => ["smaller_resized", "large_resized"]
])

exported = transloadit.step("exported", "/s3/store", [
  :use => [":original", "large_filtered", "large_resized", "optimized", "smaller_filtered", "smaller_resized"],
  :credentials => "YOUR_AWS_CREDENTIALS",
  :url_prefix => "https://demos.transloadit.com/"
])

transloadit.assembly([
  :steps => [_original, large_filtered, smaller_filtered, large_resized, smaller_resized, optimized, exported]
])

# Add files to upload
files = []
files.push("chameleon-small.jpg")
files.push("damselfly.jpg")
files.push("patrick-tomasso-60176.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', 'MY_TRANSLOADIT_SECRET')
assembly = tl.new_assembly()

# Set Encoding Instructions
assembly.add_step(":original", "/upload/handle", {})

assembly.add_step("large_filtered", "/file/filter", {
  'use': ':original',
  'result': True,
  'accepts': [['${file.meta.width}', '>', '2048'], ['${file.meta.height}', '>', '2048']],
  'condition_type': 'or'
})

assembly.add_step("smaller_filtered", "/file/filter", {
  'use': ':original',
  'result': True,
  'accepts': [['${file.meta.width}', '<=', '2048'], ['${file.meta.height}', '<=', '2048']],
  'condition_type': 'or'
})

assembly.add_step("large_resized", "/image/resize", {
  'use': 'large_filtered',
  'result': True,
  'resize_strategy': 'fit',
  'width': 2048,
  'height': 2048,
  'imagemagick_stack': 'v3.0.0'
})

assembly.add_step("smaller_resized", "/image/resize", {
  'use': 'smaller_filtered',
  'result': True,
  'resize_strategy': 'fit',
  'width': '${file.meta.width}',
  'height': '${file.meta.height}',
  'imagemagick_stack': 'v3.0.0'
})

assembly.add_step("optimized", "/image/optimize", {
  'result': True,
  'use': ['smaller_resized', 'large_resized']
})

assembly.add_step("exported", "/s3/store", {
  'use': [':original', 'large_filtered', 'large_resized', 'optimized', 'smaller_filtered', 'smaller_resized'],
  'credentials': 'YOUR_AWS_CREDENTIALS',
  'url_prefix': 'https://demos.transloadit.com/'
})

# Add files to upload
assembly.add_file(open('chameleon-small.jpg', 'rb'))
assembly.add_file(open('damselfly.jpg', 'rb'))
assembly.add_file(open('patrick-tomasso-60176.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 (
  "context"
  "fmt"
  "github.com/transloadit/go-sdk"
)

func main() {
  // Create client
  options := transloadit.DefaultConfig
  options.AuthKey = "YOUR_TRANSLOADIT_KEY"
  options.AuthSecret = "MY_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("large_filtered", map[string]interface{}{
    "use": ":original",
    "robot": "/file/filter",
    "result": true,
    "accepts": [["${file.meta.width}", ">", "2048"], ["${file.meta.height}", ">", "2048"]],
    "condition_type": "or",
  })
  
  assembly.AddStep("smaller_filtered", map[string]interface{}{
    "use": ":original",
    "robot": "/file/filter",
    "result": true,
    "accepts": [["${file.meta.width}", "<=", "2048"], ["${file.meta.height}", "<=", "2048"]],
    "condition_type": "or",
  })
  
  assembly.AddStep("large_resized", map[string]interface{}{
    "use": "large_filtered",
    "robot": "/image/resize",
    "result": true,
    "resize_strategy": "fit",
    "width": 2048,
    "height": 2048,
    "imagemagick_stack": "v3.0.0",
  })
  
  assembly.AddStep("smaller_resized", map[string]interface{}{
    "use": "smaller_filtered",
    "robot": "/image/resize",
    "result": true,
    "resize_strategy": "fit",
    "width": "${file.meta.width}",
    "height": "${file.meta.height}",
    "imagemagick_stack": "v3.0.0",
  })
  
  assembly.AddStep("optimized", map[string]interface{}{
    "result": true,
    "use": ["smaller_resized", "large_resized"],
    "robot": "/image/optimize",
  })
  
  assembly.AddStep("exported", map[string]interface{}{
    "use": [":original", "large_filtered", "large_resized", "optimized", "smaller_filtered", "smaller_resized"],
    "robot": "/s3/store",
    "credentials": "YOUR_AWS_CREDENTIALS",
    "url_prefix": "https://demos.transloadit.com/",
  })
  
  // Add files to upload
  assembly.AddFile("chameleon-small.jpg"))
  assembly.AddFile("damselfly.jpg"))
  assembly.AddFile("patrick-tomasso-60176.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: ")
  fmt.Printf("  - %s\n", info.Results[":original"][0].SSLURL)
  fmt.Printf("  - %s\n", info.Results["large_filtered"][0].SSLURL)
  fmt.Printf("  - %s\n", info.Results["smaller_filtered"][0].SSLURL)
  fmt.Printf("  - %s\n", info.Results["large_resized"][0].SSLURL)
  fmt.Printf("  - %s\n", info.Results["smaller_resized"][0].SSLURL)
  fmt.Printf("  - %s\n", info.Results["optimized"][0].SSLURL)
  fmt.Printf("  - %s\n", info.Results["exported"][0].SSLURL)
}

// implementation 'com.transloadit.sdk:transloadit:1.0.0

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) {
    // Initialize the Transloadit client
    Transloadit transloadit = new Transloadit("YOUR_TRANSLOADIT_KEY", "MY_TRANSLOADIT_SECRET");
    
    Assembly assembly = transloadit.newAssembly();
    
    // Set Encoding Instructions
    Map<String, Object> _originalStepOptions = new HashMap();
    assembly.addStep(":original", "/upload/handle", _originalStepOptions);
    
    Map<String, Object> large_filteredStepOptions = new HashMap();
    large_filteredStepOptions.put("use", ":original");
    large_filteredStepOptions.put("result", true);
    large_filteredStepOptions.put("accepts", new String[] { new String[] { "${file.meta.width}", ">", "2048" }, new String[] { "${file.meta.height}", ">", "2048" } });
    large_filteredStepOptions.put("condition_type", "or");
    assembly.addStep("large_filtered", "/file/filter", large_filteredStepOptions);
    
    Map<String, Object> smaller_filteredStepOptions = new HashMap();
    smaller_filteredStepOptions.put("use", ":original");
    smaller_filteredStepOptions.put("result", true);
    smaller_filteredStepOptions.put("accepts", new String[] { new String[] { "${file.meta.width}", "<=", "2048" }, new String[] { "${file.meta.height}", "<=", "2048" } });
    smaller_filteredStepOptions.put("condition_type", "or");
    assembly.addStep("smaller_filtered", "/file/filter", smaller_filteredStepOptions);
    
    Map<String, Object> large_resizedStepOptions = new HashMap();
    large_resizedStepOptions.put("use", "large_filtered");
    large_resizedStepOptions.put("result", true);
    large_resizedStepOptions.put("resize_strategy", "fit");
    large_resizedStepOptions.put("width", 2048);
    large_resizedStepOptions.put("height", 2048);
    large_resizedStepOptions.put("imagemagick_stack", "v3.0.0");
    assembly.addStep("large_resized", "/image/resize", large_resizedStepOptions);
    
    Map<String, Object> smaller_resizedStepOptions = new HashMap();
    smaller_resizedStepOptions.put("use", "smaller_filtered");
    smaller_resizedStepOptions.put("result", true);
    smaller_resizedStepOptions.put("resize_strategy", "fit");
    smaller_resizedStepOptions.put("width", "${file.meta.width}");
    smaller_resizedStepOptions.put("height", "${file.meta.height}");
    smaller_resizedStepOptions.put("imagemagick_stack", "v3.0.0");
    assembly.addStep("smaller_resized", "/image/resize", smaller_resizedStepOptions);
    
    Map<String, Object> optimizedStepOptions = new HashMap();
    optimizedStepOptions.put("result", true);
    optimizedStepOptions.put("use", new String[] { "smaller_resized", "large_resized" });
    assembly.addStep("optimized", "/image/optimize", optimizedStepOptions);
    
    Map<String, Object> exportedStepOptions = new HashMap();
    exportedStepOptions.put("use", new String[] { ":original", "large_filtered", "large_resized", "optimized", "smaller_filtered", "smaller_resized" });
    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("chameleon-small.jpg"));
    assembly.addFile(new File("damselfly.jpg"));
    assembly.addFile(new File("patrick-tomasso-60176.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
    }
  }
}