protocol://[value]

pattern reqHeaders://x-proxy=Whistle   # Set request headers
pattern statusCode://404               # Modify status code
pattern file://({"ec":0})              # Respond with inline content (value inside parentheses: `{"ec":0}`)

``` ua.txt
Mozilla/5.0 (iPhone; CPU iPhone OS 16_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.6 Mobile/15E148 Safari/604.1
```
pattern ua://{ua.txt}

``` headers.json
user-agent: Mozilla/5.0 (iPhone; CPU iPhone OS 16_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.6 Mobile/15E148 Safari/604.1
```
pattern reqHeaders://{headers.json}

pattern reqHeaders:///User/xxx/filepath             # Load operation content from local file
pattern resHeadrs://https://example.com/config.json # Load JSON object from remote URL
pattern resHeaders://temp/blank.json                # Through editing temporary files

pattern protocol://temp.json

protocol://(value)

pattern protocol://`...${version}...`

``` test.key
...${reqId}...
...${version}...
```
pattern protocol://`{test.key}`

pattern protocol://`(...${now}...)`

``` test.txt
now: ${now}
random: ${random}
randomUUID: ${randomUUID}
reqId: ${reqId}
url.protocol: ${url.protocol}
url.hostname: ${url.hostname}
url.host: ${url.host}
url.port: ${url.port}
url.path: ${url.path}
url.pathname: ${url.pathname}
url.search; ${url.search}
query: ${query.name}
url: ${url}
querystring: ${querystring}
searchstring: ${searchstring}
method: ${method}
reqHeaders.accept: ${reqHeaders.accept}
resHeaders.content-type: ${resHeaders.content-type}
version: ${version}
port: ${port}
host: ${host}
realPort: ${realPort}
realHost: ${realHost}
clientIp: ${clientIp}
clientPort: ${clientPort}
serverIp: ${serverIp}
serverPort: ${serverPort}
reqCookies.test: ${reqCookies.test}
resCookies.test: ${resCookies.test}
statusCode: ${statusCode}
env.USER: ${env.USER}
```

www.test.com/index.html file://`{test.txt}`

now: 1752301623295
random: 0.6819241513880432
randomUUID: e917b9fc-e2ef-4255-9209-11eb417235c5
reqId: 1752301623294-339
url.protocol: https:
url.hostname: www.test.com
url.host: www.test.com
url.port: 
url.path: /index.html?name=avenwu
url.pathname: /index.html
url.search; ?name=avenwu
query: avenwu
url: https://www.test.com/index.html?name=avenwu
querystring: ?name=avenwu
searchstring: ?name=avenwu
method: GET
reqHeaders.accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7
resHeaders.content-type: 
version: 2.9.100
port: 8899
host: 
realPort: 8899
realHost: 
clientIp: 127.0.0.1
clientPort: 60582
serverIp: 
serverPort: 
reqCookies.test: 
resCookies.test: 
statusCode: 
env.USER: av

{
  "key1": value1,
  "key2": value2,
  "keyN": valueN
}

key1: value1
key2:value2
keyN: valueN

a.b.c: 123
c\.d\.e: abc

{
  "a": {
    "b": {
      "c": 123
    }
  },
  "c.d.e": "abc"
}

key1=value1&key2=value2&keyN=valueN

# Basic Syntax
pattern method://NewMethod

# Example
www.example.com/path method://post

# Example 1: Change all request methods to POST
www.example.com/path method://post

# Example 2: Change only PUT requests to POST
www.example.com/path method://post includeFilter://m:put

# Example 3: Modify method based on request body content
www.example.com/api method://put includeFilter://b:cmdname=test

www.example.com/path/to www.test.com/test

# Add/Replace parameters
pattern urlParams://({"key":"value"})

# Delete parameter
pattern delete://urlParams.paramName

# Example: Modify parameters and delete a specific parameter
www.example.com/api urlParams://({"cmdname":"Test"}) delete://urlParams.oldParam

# Regular expression replacement
pattern pathReplace://({"/old/ig":"new"})

# Keyword replacement
pattern pathReplace://({"old":"new"})

# Force using standard HTTPS (disable HTTP/2)
pattern disable://h2

# Add/Replace request header
pattern reqHeaders://({"Header-Name":"value"})

# Delete request header
pattern delete://reqHeaders.headerName

# Example
www.example.com reqHeaders://({"X-Custom-Header":"test"})

pattern reqMerge://({"newField":"value"})

# Regular expression replacement
pattern reqReplace://({"/search/ig":"replace"})

# Keyword replacement
pattern reqReplace://({"search":"replace"})

pattern reqBody://(NewContent)

# Delete specific field
pattern delete://reqBody.fieldName

# Delete entire request body
pattern delete://reqBody

# Replace existing response status code (request reaches server)
pattern replaceStatus://500

# Respond directly with status code (request not sent to server)
pattern statusCode://500

# Add/Replace response header
pattern resHeaders://({"Header-Name":"value"})

# Delete response header
pattern delete://resHeaders.headerName

pattern resMerge://({"newData":"value"})

pattern resReplace://({"/old/ig":"new"})

# Replace content returned by server
pattern resBody://(NewContent)

# Request not sent to server
pattern file://(Content to return directly) resType://html

# Delete response body field
pattern delete://resBody.fieldName

# Clear response body
pattern delete://resBody

# Add/Replace Trailers
pattern trailers://({"Trailer-Name":"value"})

# Delete Trailers
pattern delete://trailers.trailerName

# Set IP address
pattern 127.0.0.1

# Set IP and port
pattern 127.0.0.1:8080

# CNAME effect (pointing to another host)
pattern host://www.target.com:8080

# HTTP proxy
pattern proxy://127.0.0.1:8080

# SOCKS5 proxy
pattern socks://127.0.0.1:1080

# Supports domain name
pattern proxy://proxy.example.com:8080

# Example 1: Only host configuration takes effect
pattern 127.0.0.1:8080 socks://10.1.1.1:1080

# Example 2: Only proxy configuration takes effect
pattern 127.0.0.1:8080 socks://10.1.1.1:1080 ignore://host

# Example 3: Both host and proxy take effect
pattern 127.0.0.1:8080 socks://10.1.1.1:1080 lineProps://proxyHost

pattern weinre://DebugSessionName

pattern log://LogSessionName

# Direct inline
protocol://({"key":"value"})

# Embedded value
protocol://{embeddedKey}

# Values configuration
protocol://{valuesKey}

# Local file
protocol:///path/to/file.json

# Remote URL
protocol://https://example.com/data.json