> For the complete documentation index, see [llms.txt](https://docs.proxyman.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.proxyman.com/scripting/snippet-code.md).
# Snippet Code
The collection of useful snippet code for the Scripting tool
## 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 , we will get back to help you âï¸
{% endhint %}
{% hint style="success" %}
Use [Proxyman MCP](/mcp.md) with your agent (Codex/Claude Code) to help you generate a Scripting easily 🚀
{% 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)
* [Upstream ALPN and HTTP/2 settings](#upstream-alpn-and-http2-settings)
* [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;
}
```
## Upstream ALPN and HTTP/2 settings
Available in Proxyman v26.0.0 or later for macOS. See [HTTP/2](/basic-features/http2.md) for setup.
Set `request.upstream` in `onRequest` to change how Proxyman connects to the server. Enable SSL Proxying for the HTTPS domain. H2 overrides also require HTTP/2 enabled in Settings and an HTTP/2 client connection to Proxyman.
```javascript
async function onRequest(context, url, request) {
request.upstream = {
tls: { alpnProtocols: ["h2"] },
http2: {
headerTableSize: 65536,
initialWindowSize: 6291456,
maxHeaderListSize: 262144
}
};
return request;
}
```
ALPN accepts a nonempty list with no duplicates:
* `["h2"]`: Require HTTP/2. Fail if the server cannot use it.
* `["h2", "http/1.1"]`: Allow HTTP/1.1 fallback.
* `["http/1.1"]`: Use HTTP/1.1.
HTTP/2 values must be integers from `0` to the maximum below. Omitted or `null` fields use defaults.
| Setting | Default | Maximum |
| ------------------- | --------- | ------------ |
| `headerTableSize` | `65536` | `4294967295` |
| `initialWindowSize` | `6291456` | `2147483647` |
| `maxHeaderListSize` | `262144` | `4294967295` |
To reset all overrides, delete `request.upstream` or set it to `null`. Invalid or incompatible settings return a local `502` Scripting error.
## 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 \*
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
```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
}
```
## 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
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;
}
```