# Snippet Code

## 1. What's it?

A collection of snippet Javascript code for the Scripting Tool.

{% hint style="info" %}
Could not find the Snippet Code you are looking for?

Please open a ticket at <https://github.com/ProxymanApp/Proxyman>, we will get back to help you ⭐️
{% endhint %}

## 2. Common on Request and Response

* [Update Headers of Request or Response](#http-header)
* [Update Request Query](#request-query)
* [Update URLEncoded Form Request Body](#urlencoded-form-body)
* [Update JSON Request or Response Body](#json-body)
* [Map a local file to Response's Body like Map Local Tool](#map-a-local-file-to-responses-body-like-map-local-tool-proxyman-2.25.0+)
* [Change Request Scheme, Host, Port, Path](#change-request-destination-scheme-host-port-path)
* [HTTP to HTTPS](#http-to-https)
* [HTTPS to HTTP](#http-to-https-1)
* [Change Request Method](#change-response-http-status-code)
* [Change Response Status Code](#change-response-http-status-code)
* [Logging](#logging)
* [Use JSON File as a Body of Request or Response](#use-json-file-as-a-body-of-request-or-response)
* [Use multiple JSON files](#use-multiple-json-files)
* [Local Map for GraphQL](#map-local-with-graphql)
* [Use ArrayBuffer in Request/Response Body](#use-arraybuffer-in-request-response-body)
* [Preserve the Host](#preserve-the-host)
* [Comment & Highlight with color](#comment-and-highlight-with-color)
* [Abort (close) the request/response connection (Like Block List Tool)](#abort-the-request-response-like-block-list-tool)

#### Multipart/form-data

* [Read, add, update, or remove a part of multipart/form-data](#multipart-form-data-1)

## 3. Addons

* [Base64 Encoding/Decoding or atob/btoa](#use-base64-addon)
* [Hashing Addon (MD5, SHA1, SHA256, SHA512)](#use-hashing-addon-md-5-sha-1-sha-256-sha-512)
* [UUIDv4 Generator](#use-uuid-v4-addon)
* [Deflate/Inflate or GZip/UnGZip](#deflate-inflate-and-gzip-ungzip)
* [JWT Decode](#jwt-decode)

## 3.1 Use \`npm install\`

* [use \`npm install dayjs\` to install 3rd npm packages](#use-npm-install)

## 4. Regex

* [Check if a given string contains only numbers](#regex)
* [Regex to get the Scheme, Host, Port, Path, and Query of the URL](#regex-to-get-the-scheme-host-port-path-and-query-of-the-url)

## 5. Import / Export Files

* [Import JSON File](#json)
* [Import Binary Data (Image)](#binary-file)
* [Import Text-based file (css, html, js....)](#text-based-file)
* [Import Files without using the "Import Tool"](#import-file-without-using-the-import-tool)
* [Write / Export to a local file](#write-export-to-a-local-file)
* [Check file exist](#check-if-the-first-exist)
* [Read a Local File](#read-a-file)
* [Use Response as Mock API](#use-as-mock-api)

## 6. Miscellaneous

* [By-pass CORS](#by-pass-cors)
* [Inject a Header to the Request or Response](#inject-header-to-request-response)
* [Response delay with sleep() function](#response-delay-with-sleep-function)

## 7. Encryption/Decryption

* [AES](#aes-encryption-decryption)
* [DES](#des-encryption-decryption)

## 8. Map Remote with Scripting

* [Map v1 to v2 Endpoints](#map-v1-to-v2-endpoints)
* [Map Localhost to Production](#map-localhost-to-production)
* [Map Production to Localhost](#map-production-to-localhost)

## 9. Make Async/await HTTP Request (macOS)

* [GET Request with Query](#get-request-with-query)
* [POST Request with JSON Body](#post-request-with-json-body)
* [POST Request with application/x-www-form-urlencoded](#post-request-with-application-x-www-form-urlencoded-body)
* [PUT / PATCH / DELETE Request](#put-patch-delete-request)

## 9.1. Make Async/await HTTP Request (Windows/Linux)

* [Make a request with the Axios library](#make-async-await-http-request-windows-linux)

## 10. URL and URLSearchParams

* [URL and URLSearchParams](#url-and-urlsearchparams)

## 11. Access Environment Variables

* [Manually read system environment variables](#reload-system-environment-variables)

## 12. Websocket

* [Change the Websocket URL, Headers](#change-websocket-url-requests-response-header)

## HTTP Header

#### Add/Update: Request or Response Header

```javascript
function onRequest(context, url, request) {
    // Add or update Request Header
    request.headers["X-Proxyman-Key"] = "My-Value";
    request.headers.name = "Proxyman";
    return request;
}

function onResponse(context, url, request, response) {
    // Add or update Response Header
    response.headers["X-Proxyman-Key"] = "My-Value";
    response.headers.id = 100;
    return response;
}
```

#### Delete: Request or Response Header

```javascript
function onRequest(context, url, request) {
    delete request.headers["X-Proxyman-Key"];
    return request;
}

function onResponse(context, url, request, response) {
    delete response.headers["X-Proxyman-Key"];
    return response;
}

```

## Request Query

#### Add/Update

```javascript
function onRequest(context, url, request) {
    request.queries["name"] = "Proxyman";
    request.queries["platform"] = "macOS";
    // => http://proxyman.io?name=Proxyman&platform=macOS
    return request;
}
```

#### Delete

```javascript
function onRequest(context, url, request) {
    delete request.queries["name"];
    delete request.queries["platform"];
    return request;
}

```

## URLEncoded Form Body

#### Add/Update

```javascript
function onRequest(context, url, request) {
    // Make sure the Response Header is application/x-www-form-urlencoded
    // Content-Type: application/x-www-form-urlencoded   
    var formBody = request.body;

    formBody["name"] = "Proxyman";
    formBody["flatform"] = "macOS";

    request.body = formBody; // => name=Proxyman&platform=macOS
    return request;
}

```

#### Delete

```javascript
function onRequest(context, url, request) {
    // Content-Type: application/x-www-form-urlencoded
    var formBody = request.body;

    delete formBody["name"];
    delete formBody["flatform"];

    request.body = formBody;
    return request;
}

```

## Change Request Destination (scheme, host, port, path)

```javascript
function onRequest(context, url, request) {
    request.scheme = "http";
    request.host = "proxyman.dev";
    request.port = 9090;
    request.path = "v1/data/user";
    return request;
}
```

## HTTP to HTTPS

```javascript
function onRequest(context, url, request) {
    request.scheme = "http";
    request.port = 80; // Don't forget to override the port
    return request;
}
```

## HTTPS to HTTP

```javascript
function onRequest(context, url, request) {
    request.scheme = "https";
    request.port = 443; // Don't forget to override the port
    return request;
}
```

## Change HTTP Request Method

```javascript
function onRequest(context, url, request) {
    request.method = "POST";
    return request;
}
```

## Change Response HTTP Status Code

```javascript
function onResponse(context, url, request, response) {
    response.statusCode = 404;
    return response;
}
```

## JSON Body

#### On Request

```javascript
function onRequest(context, url, request) {
    // Set JSON content
    request.headers["Content-Type"] = "application/json";
    
    // Get Request body
    var jsonBody = request.body;
    
    // Modify data
    jsonBody["name"] = "Proxyman";
    jsonBody["flatform"] = "macOS";
    jsonBody["info"] = { 
                        "website": "proxyman.io",
                        "region": "Earth"
                       };
    // Set it again        
    request.body = jsonBody;
    return request;
}
```

#### On Response

```javascript
function onResponse(context, url, request, response)  {
    // Set JSON content
    response.headers["Content-Type"] = "application/json";
  
    // Get Request body
    var jsonBody = response.body;
    
    // Modify data
    jsonBody["name"] = "Proxyman";
    jsonBody["flatform"] = "macOS";
    jsonBody["info"] = { 
                        "website": "proxyman.io",
                        "region": "Earth"
                       };
    // Set it again        
    response.body = jsonBody;
    return response;
}

```

#### Multipart/form-data

From Proxyman macOS 6.6.0 or later, you can read, add, delete a multipart/form-data

```javascript
function onRequest(context, url, request) {
  // Only run for multipart requests
  if (!request.multipart) {
    return request;
  }

  var parts = request.multipart;

  // 1) List parts (debug)
  console.log("Multipart parts:", parts);

  // 2) Modify a text part by name
  for (var i = 0; i < parts.length; i++) {
    if (parts[i].name === "text_field") {
      var p = parts[i];
      p.body = "Updated text from script";
      parts[i] = p;
    }
  }

  // 3) Modify a file part by name (binary body as [UInt8])
  for (var i = 0; i < parts.length; i++) {
    if (parts[i].name === "file_field") {
      var p = parts[i];
      p.body = [72, 101, 108, 108, 111]; // "Hello"
      p.fileName = "hello.txt";
      p.contentType = "text/plain";
      parts[i] = p;
    }
  }

  // 4) Add a new text part
  parts.push({
    name: "new_field",
    body: "Added by script"
  });

  // 5) Remove a part by name
  var filtered = [];
  for (var i = 0; i < parts.length; i++) {
    if (parts[i].name !== "remove_me") {
      filtered.push(parts[i]);
    }
  }

  // Apply updates
  request.multipart = filtered;

  return request;
}
```

#### Map a local file to Response's Body like Map Local Tool (Proxyman 2.25.0+)

It's a convenient way to directly set a local file to a Body by using `bodyFilePath` property

```javascript
// For request
request.bodyFilePath = "~/Desktop/image.png";

// For response
response.bodyFilePath = "~/Desktop/image.png";
```

```javascript
function onResponse(context, url, request, response) {
 
  response.headers["Content-Type"] = "image/png";
  response.bodyFilePath = "~/Desktop/image.png";
 
  // Done
  return response;
}
```

```javascript
function onResponse(context, url, request, response) {
 
  response.headers["Content-Type"] = "application/json";
  response.bodyFilePath = "~/Desktop/my_response.json";
 
  // Done
  return response;
}
```

#### Use JSON File as a Body of Request or Response

It's possible to use your JSON file and set it as a Request/Response's body

Please follow this [tutorial](#json).

#### Use multiple JSON files

You can use set a different body for each matching endpoint by using the IF statement.

1. Follow this [tutorial](#json) to understand how to import a JSON file to the script
2. Set Script Rule with wildcard or Regex pattern that can match many endpoints. E.g <https://my-domain.com/v\\>\*
3. Use \`includes()\` to check whether or not the endpoint is matched

```javascript
const file_1 = require("@users/myfile_1.json");
const file_2 = require("@users/myfile_2.json");
const file_3 = require("@users/myfile_3.json");

function onResponse(context, url, request, response) {
  
  // Set JSON content
  response.headers["Content-Type"] = "application/json";
  
  // Check
  if (url.includes("v1/data")) {
    response.body = file_1
  } else if (url.includes("v2/login")) {
      response.body = file_2
  } else if (url.includes("v3/user")) {
      response.body = file_3
  }

  // Done
  return response;
}
```

#### Map Local with GraphQL

Read more at <https://github.com/ProxymanApp/Proxyman/issues/412#issuecomment-697101594>

```javascript
// Import your JSON file here 
const file = require("@users/B02D96D5.default_message_32E64A5B.json");

function onRequest(context, url, request) {

  // 1. Extract the queryName from the request
  var queryName = request.body.query.match(/\S+/gi)[1].split('(').shift();

  // 2. Save to sharedState
  sharedState.queryName = queryName

  // Done
  return request;
}

function onResponse(context, url, request, response) {

  // 3. Check if it's the request we need to map
  if (sharedState.queryName == "user") {
    
    // 4. Import the local file by Action Button -> Import
    // Get the local JSON file and set it as a body (like Map Local)
    response.headers["Content-Type"] = "application/json";
    response.body = file;
  }

  // Done
  return response;
}
```

#### Use ArrayBuffer in Request/Response Body

Since Javascript doesn't have the Data object type, the Data Body will convert to **Base64 Encoded String** in Javascript. To pass **Uint8Array**, **blob**, or **ArrayBuffer** to the body, make sure you convert to **Base64 Encoded String** and set the ContentType to `application/octet-stream`

Proxyman will convert Base64 Encoding to ArrayBuffer, so the client will receive the data properly.

```javascript
// Import
const { btoa } = require('@addons/Base64.js');

function onResponse(context, url, request, response) {
  // Construct the ArrayBuffer
  const buffer = new ArrayBuffer(256)
  const view = new Uint8Array(buffer)
  for (let i = 0; i < view.length; i++) {
    view[i] = i
  }
  
  // Convert ArrayBuffer to Base64String
  var newBody = btoa(String.fromCharCode.apply(null, new Uint8Array(buffer)));
  
  // Set new body
  response.body = newBody;
  response.statusCode = 200
  response.headers['Content-Type'] = 'application/octet-stream'

  // Done
  return response;
}
```

#### Preserve the Host

```javascript
function onRequest(context, url, request) {
    request.preserveHostHeader = true
    return request
}
```

#### Comment & Highlight with color

Use `comment` or `color` to highlight on the main table view.

```javascript
function onRequest(context, url, request) {
    request.comment = "It's a Request"
    request.color = "red" // red, blue, yellow, purple, gray, green
    return request
}

function onResponse(context, url, request, response) {
    response.comment = "It's a Response"
    response.color = "yellow" // red, blue, yellow, purple, gray, green
    return response
}
```

![Use Scripting for Color and Comment](/files/-MgxL1JqOH7m5LREXl8i)

## Import Files with require()

#### JSON

1. Prepare a JSON file and save it to your Desktop

```javascript
// myfile.json
{
  "name": "Proxyman",
  "platform": "macOS",
  "info": {
    "website": "proxyman.io",
    "region": "Earth"
  }
}
```

2\. More -> Import JSON or Other Files. Then selecting your file

![](/files/-MYrj03fD9OTiOu_w1VK)

3\. Proxyman will add the import code to the top of the script

```javascript
// ~/Library/Application Support/com.proxyman.NSProxy/users/myfile.json
const file = require("@users/myfile.json");

function onResponse(context, url, request, response) {
  // 1. Set header to JSON if need
  response.headers["Content-Type"] = "application/json";

  // 2. Set Body as a imported file
  response.body = file;
  
  return response;
}
```

{% hint style="info" %}
The selected file is copied to **\~/Library/Application\ Support/com.proxyman.NSProxy/users** folder.
{% endhint %}

{% hint style="info" %}
To support other format files, such as image, text, pdf. Make sure you have correct **Header Content-Type**
{% endhint %}

#### Binary File

1. Follow the same above instruction (Select your Binary File)
2. Set it as a body

```javascript
// ~/Library/Application Support/com.proxyman.NSProxy/users/myscreenshot.png
const file = require("@users/myscreenshot.png");

function onResponse(context, url, request, response) {
  // Set header
  response.headers["Content-Type"] = "image/png";

  // Set Body
  response.body = file;
  
  return response;
}
```

#### Text-Based File

1. Follow the same above instruction (Select your Binary File)
2. Set it as a body

```javascript
// ~/Library/Application Support/com.proxyman.NSProxy/users/main.css
const file = require("@users/main.css");

function onResponse(context, url, request, response) {
  // Set header
  response.headers["Content-Type"] = "text/css";

  // Set Body
  response.body = file;
  
  return response;
}
```

#### Import File without using the "Import Tool"

From Proxyman 2.24.0+, you can import any files without using the "Import File".

```javascript
// Import your file from your Desktop folder
const file = require("~/Desktop/myfile.json");

function onResponse(context, url, request, response) {

  // 1. Set header to JSON if need
  response.headers["Content-Type"] = "application/json";

  // 2. Set Body as a imported file
  response.body = file;
  
  return response;
}
```

* If the file has ".js" as an extension => Proxyman will execute it as a JS Script
* Otherwise, Proxyman will import it as normal

{% hint style="info" %}
Only files that are imported by using the "Import Tool", are included when exporting the script to your colleague.
{% endhint %}

#### Use as Mock API

You can use Scripting as a Mock API by following this [guideline](https://docs.proxyman.io/scripting/script#8-use-scripting-as-a-mock-api).

## Using Addons

[Full list of built-in addons](/scripting/addons.md)

#### Use Base64 Addon

```javascript
// Encode Base64
const { btoa } = require("@addons/Base64.js")

// Usage:
var text = "HelloWorld";
var encodedText = btoa(text);
```

```javascript
// Decode Base64
const { atob } = require("@addons/Base64.js")

// Usage:
var text = atob("aGVsbG8=");
```

#### Use Hashing Addon (MD5, SHA1, SHA256, SHA512)

```javascript
// Hash MD5
const { md5 } = require("@addons/MD5.js")

// Usage:
var hashedText = md5("Hello World");
```

```javascript
// Hash SHA1
const { sha1 } = require("@addons/SHA1.js")

// Usage:
var hashedText = sha1("Hello World");
```

#### Use UUID-v4 Addon

```javascript
// Hash MD5
const { uuidv4 } = require("@addons/UUID.js")

// Usage:
var uuid = uuidv4();
```

## Deflate/Inflate and GZip/UnGZip

#### Deflate/inflate

```javascript
const { inflate, deflate } = require("@addons/Pako.js")

// Compress
var input = "Hello World from Pako!!!"
var result = deflate(input);
console.log(result); // eJzzSM3JyVcIzy/KSVFIK8rPVQhIzM5XVFQEAGsMB/8=

// Decompress
var text = 'eJzzSM3JyVcIzy/KSVFIK8rPVQhIzM5XVFQEAGsMB/8=';
var rawText = inflate(text);
console.log(rawText); // Hello World from Pako!!!
```

#### GZip/UnGZip

```javascript
const { ungzip, gzip } = require("@addons/Pako.js")

// Compress
var text =  'HelloWorld';
var result = gzip(text);
console.log(result); // H4sIAAAAAAAAA/NIzcnJD88vykkBAHkMd3cKAAAA

// Decompress
var text =  'H4sIAAAAAAAAA/NIzcnJD88vykkBAHkMd3cKAAAA';
var rawText = ungzip(text);
console.log(rawText); // HelloWorld
```

#### JWT Decode

```javascript
const { jwtDecode } = require('@addons/JWTDecode.js');

var text = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c';
var jSONObject = jwtDecode(text)
```

## Logging

```javascript
// Print the obj
const myObj = {};
console.log(myObj);

// Print type of the obj
console.log(typeof(myObj));
```

## Regex

#### Only number

```javascript
//Init Regex
var reg = /^-?\d*\.?\d*$/;

if (reg.test("123123123")) {
    console.log("Matched");
}
```

#### Regex to get the Scheme, Host, Port, Path, and Query of the URL

```javascript
function onRequest(context, url, request) {
  console.log(url);

  // Get each part
  const regex = /^(https?):\/\/([^:\/\n]+)(?::(\d+))?([^#\n?]+)(?:\?([^#\n]+))?/;
  const [, scheme, host, port, path, query] = url.match(regex);

  // Assign again
  request.scheme = scheme;
  request.host = host;
  if (port !== undefined) {
    request.port = parseInt(port);
  }
  request.path = path;

  // Log
  console.log("----------");
  console.log(scheme);
  console.log(host);
  console.log(port);
  console.log(path);

  // Done
  return request;
}
```

## Miscellaneous

#### By-pass CORS

```javascript
function onResponse(context, url, request, response) {  

  // Allow all
  response.headers["Access-Control-Allow-Origin"] = "*";
  response.headers["Access-Control-Allow-Headers"] = "*"；
  response.headers["Access-Control-Allow-Methods"] = "*";

  // Done
  return response;
}
```

#### Inject Header to Request / Response

```javascript
function onRequest(context, url, request) {
  // add header
  request.headers["My-Injected-Header"] = "Proxyman";
  return request
}

function onResponse(context, url, request, response) {    
  // add header
  response.headers["My-Injected-Header"] = "Proxyman";
  return response;
}

```

#### Response delay with sleep() function

the It's useful for simulating the "Slow Network" on a particular Request or Response. You can check out the [Network Conditions tool](https://docs.proxyman.com/scripting/pages/-MU7kJFAGgtfxvjkhLBh#1.-whats-it) for GUI.

* macOS

```javascript
function onResponse(context, url, request, response) {
  console.log("Start sleep");
  
  // Sleep 5 seconds
  sleep(5000);
  
  // Done
  return response;
}
```

* Windows/Linux

```javascript
async function onResponse(context, url, request, response) {
  console.log("Start sleep");
  
  // Sleep 5 seconds
  // Must use `await` keyword on Windows/Linux
  await sleep(5000);
  
  // Done
  return response;
}
```

#### AES Encryption/Decryption

```javascript
const { encryptAES, decryptAES } = require("@addons/CryptoJS.js")

function onRequest(context, url, request) {
  
  // Encrypt
  var message = 'my message from Proxyman';
  var password = 'secret key 123';
  var ciphertext = encryptAES(message, password);
  
  // Decrypt
  var originalText = decryptAES(ciphertext, password);

  // Done
  return request;
}
```

#### DES Encryption/Decryption

```javascript
const { encryptDES, decryptDES } = require("@addons/CryptoJS.js")

function onRequest(context, url, request) {
  
  // Encrypt
  var message = 'my message from Proxyman';
  var password = 'secret key 123';
  var ciphertext = encryptDES(message, password);
  
  // Decrypt
  var originalText = decryptDES(ciphertext, password);

  // Done
  return request;
}
```

#### Write / Export to a local file

* Override Mode

```javascript
function onResponse(context, url, request, response) {

  // Write to single file
  writeToFile(response.body, "~/Desktop/body.json");
  
  // Write the Body to file with flow ID
  writeToFile(response.body, "~/Desktop/sample-" + context.flow.id);
  
  // Done
  return response;
}
```

* Append Mode (Only for Proxyman 3.6.2+)

```javascript
async function onResponse(context, url, request, response) {

  // Append to the existed file
  // Or create a new file if it doesn't exist
  var opt = {appendFile: true}
  writeToFile(response.body, "~/Desktop/body.json", opt);

  // Done
  return response;
}
```

#### Check if the first exist

* Available: Proxyman macOS 5.4.0+

```javascript
async function onRequest(context, url, request) {

  const filePath = "~/Desktop/myfile.json"
  
  // check if the file exists
  if (isFileExists(filePath)) {
    console.log("File exists");
  } else {
    console.log("File NOT exists");  
  }
  
  // Done
  return request;
}
```

#### Read a file

* If it's text-based -> Return a **String**
* Otherwise -> Return **Uint8Array**
* Available: Proxyman macOS 5.4.0+

```javascript
async function onRequest(context, url, request) {  // console.log(request);

  const textFilePath = "~/Desktop/myfile.json";
  
  // check exist
  if (isFileExists(filePath)) {
  
    // read from file
    const text = readFromFile(textFilePath);
    
    // pares string to JSON Object
    const obj = JSON.parse(text);
  }
  
  // Read binary file
  const binaryFilePath = "~/Desktop/screenshot.png";
  const binaryFile = readFromFile(binaryFilePath); // Uint8Array
  
  // Done
  return request;
}
```

## Map Remotes

#### Map v1 to v2 endpoints

```javascript
function onRequest(context, url, request) {
  
  // Replace v1 to v2 in URL Path
  var newPath = request.path.replace("v1", "v2");
  request.path = newPath

  // Done
  return request;
}
```

#### Map localhost to production

```javascript
function onRequest(context, url, request) {
  
  // Use production URL
  request.scheme = "https";
  request.host = "proxyman.io";
  request.port = 443;

  // Done
  return request;
}
```

#### Map production to localhost

```javascript
function onRequest(context, url, request) {
  
  // Use production URL
  request.scheme = "http";
  request.host = "localhost";
  request.port = 3000;

  // Done
  return request;
}
```

## Make async/await HTTP Request (macOS)

{% hint style="info" %}
This feature \`$http\` is available on the macOS version. To use on Windows, please check the next part.
{% endhint %}

#### GET Request with Query

```javascript
async function onResponse(context, url, request, response) {  
  // GET Request with Query
  var url = "https://httpbin.proxyman.app/get?id=proxyman&country=united%20states";
  var output = await $http.get(url);
  
  // Get Status Code
  console.log(output.statusCode);
  
  // Get body
  console.log(output.body)
  
  // Get header
  console.log(output.headers)
  
  // Done
  return response;
}
```

#### POST Request with JSON Body

```javascript
async function onResponse(context, url, request, response) {  
  // Define JSON Body and Header
  // Make sure "Content-Type" is "application/json"
  var param = {
    body: {
      "user": {
        "name": "Proxyman"
      }
    },
    headers: {
      "Content-Type": "application/json"
    }
  }

  // POST request with await
  var output = await $http.post("https://httpbin.proxyman.app/post", param);
  
  // Get Status Code
  console.log(output.statusCode);
  
  // Get body
  console.log(output.body)
  
  // Get header
  console.log(output.headers)
  
  // Done
  return response;
}
```

#### POST Request with application/x-www-form-urlencoded body

```javascript
async function onResponse(context, url, request, response) {  
  // Define form Body and Header
  // Make sure "Content-Type" is "application/x-www-form-urlencoded"
  var param = {
    body: {
      "key1": "value1",
      "key2": "value2"
    },
    headers: {
      "Content-Type": "application/x-www-form-urlencoded"
    }
  }

  // POST request with await
  var output = await $http.post("https://httpbin.proxyman.app/post", param);
  
  // Get Status Code
  console.log(output.statusCode);
  
  // Get body
  console.log(output.body)
  
  // Get header
  console.log(output.headers)
  
  // Done
  return response;
}
```

#### PUT / PATCH / DELETE Request

```javascript
async function onRequest(context, url, request) {  

  var param = {
    body: {
      "user": {
        "name": "Proxyman"
      }
    },
    headers: {
      "Content-Type": "application/json"
  }


  var output = await $http.post("https://httpbin.proxyman.app/post", param);
  var output = await $http.put("https://httpbin.proxyman.app/put", param);
  var output = await $http.delete("https://httpbin.proxyman.app/delete", param);
  
  // Done
  return request;
}
```

## Make async/await HTTP Request (Windows/Linux)

Windows/Linux ships with a built-in [Axios](https://github.com/axios/axios) library. You can easily make HTTP(s) requests with \`Axios\` syntax.

```javascript
async function getUser() {
  try {
    const response = await axios.get('https://httpbin.proxyman.app/user?ID=12345');
    console.log(response);
  } catch (error) {
    console.error(error);
  }
}
```

### Abort the request/response like Block List Tool

* Only available for Proxyman 3.11.0 and later

#### Abort the request

```javascript
function onRequest(context, url, request) {
  // drop the connection
  abort();
}
```

```javascript
function onRequest(context, url, request) {

  // Use the if to abort on certain conditions
  if (true) {
    abort();
    return; // Must return a void to stop the func
  }

  // Done
  return request;
}
```

#### Abort the response

```javascript
function onResponse(context, url, request, response) {    
  // drop the connection
  abort();
}
```

### URL and URLSearchParams

From Proxyman 4.13.0 or later, [URL](https://developer.mozilla.org/en-US/docs/Web/API/URL) and [URLSearchParams](https://developer.mozilla.org/en-US/docs/Web/API/URLSearchParams) are natively supported.

```javascript
function onRequest(context, url, request) {

  // URL
  const urlObj = new URL("https://proxyman.io/api/v1/user?id=123");
  console.log(urlObj.hostname);
  console.log(urlObj.search);
  console.log(urlObj.searchParams);

  // URLSearchParmas
  const params1 = new URLSearchParams("foo=1&bar=2");
  
  // Done
  return request;
}
```

### Reload System Environment Variables

Proxyman macOS 4.15.0 or later.

Make sure we enable the permission first, in the More Button -> Environment Variables -> Allow all scripts to read env.

```javascript
async function onRequest(context, url, request) {
  // manually reload to get the latest changes
  _reloadEnv();
  
  // get env
  console.log($PROXYMAN_ID)
  
  // Done
  return request;
}
```

### Change Websocket URL, Requests/Response Header

* Supported from macOS 6.2.0 or later
* ❌ Can NOT modify the Websocket Message. Only URL and Headers are supported.

**Map from localhost to production**

* Rule ws\://proxyman.debug:3000

```js
async function onRequest(context, url, request) {
  // console.log(request);
  console.log(url);

  request.scheme = "wss";
  request.host = "wss.httpbin-proxyman.xyz"
  request.port = 443

  // Done
  return request;
}

```

**Production to localhost**

* Rule wss\://echo.websocket.org

```js
async function onRequest(context, url, request) {
  // console.log(request);
  console.log(url);

  request.scheme = "ws";
  request.host = "proxyman.debug"
  request.port = 3000

  // Done
  return request;
}

```

#### Use \`npm install\`

Read more at [Use npm install](/scripting/use-npm-install.md)

#### Install a package

Open Terminal and install packages into Proxyman's Application Support folder:

* Install `dayjs`

```bash
$ cd "$HOME/Library/Application Support/com.proxyman.NSProxy"
$ npm install --prefix . dayjs --ignore-scripts --no-audit --no-fund
```

After installation, the package should exist in:

```
~/Library/Application Support/com.proxyman.NSProxy/node_modules
```

#### Use a package in a script

Use the package name with `require()`:

```javascript
const dayjs = require("dayjs");

async function onRequest(context, url, request) {
  const formattedDate = dayjs("2026-05-05T13:00:00Z").format("YYYY-MM-DD");
  request.headers["X-Proxyman-Dayjs"] = formattedDate;
  return request;
}
```


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.proxyman.com/scripting/snippet-code.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.