Skip to main content

​
Raxe

The main synchronous client for threat detection.

​
Constructor

from raxe import Raxe

raxe = Raxe(
    api_key: str | None = None,
    use_ml: bool = True,
    timeout: float = 30.0,
    config_path: str | None = None,
)
Parameters:
ParameterTypeDefaultDescription
api_keystr | NoneNoneAPI key. If None, reads from config or env
use_mlboolTrueEnable L2 ML detection
timeoutfloat30.0Scan timeout in seconds
config_pathstr | NoneNoneCustom config file path
Example: 
# Default configuration
raxe = Raxe()

# With custom settings
raxe = Raxe(
    api_key="raxe_your_key",
    use_ml=True,
    timeout=60.0
)

# Disable ML for faster scans
raxe = Raxe(use_ml=False)

​
scan()

Scan a single prompt for threats. 
def scan(
    self,
    prompt: str,
    *,
    use_ml: bool | None = None,
    timeout: float | None = None,
) -> ScanResult
Parameters:
ParameterTypeDefaultDescription
promptstrrequiredText to scan
use_mlbool | NoneNoneOverride ML setting for this scan
timeoutfloat | NoneNoneOverride timeout for this scan
Returns: ScanResult Raises:
  • ValidationError: If prompt is empty or invalid
  • RaxeBlockedError: If policy blocks the request
Example: 
from raxe import Raxe

raxe = Raxe()

# Basic scan
result = raxe.scan("Hello, how are you?")
print(result.is_safe)  # True

# Scan with detection
result = raxe.scan("Ignore all previous instructions")
print(result.is_safe)  # False
print(result.highest_severity)  # Severity.HIGH

# Override settings for single scan
result = raxe.scan(
    "some text",
    use_ml=False,  # Skip ML for this scan
    timeout=5.0    # Short timeout
)

​
scan_batch()

Scan multiple prompts efficiently. 
def scan_batch(
    self,
    prompts: list[str],
    *,
    use_ml: bool | None = None,
    timeout: float | None = None,
) -> list[ScanResult]
Parameters:
ParameterTypeDefaultDescription
promptslist[str]requiredList of texts to scan
use_mlbool | NoneNoneOverride ML setting
timeoutfloat | NoneNoneOverride timeout (per prompt)
Returns: list[ScanResult] Example: 
prompts = [
    "Hello, how are you?",
    "Ignore all previous instructions",
    "What is the weather?",
]

results = raxe.scan_batch(prompts)

for prompt, result in zip(prompts, results):
    status = "SAFE" if result.is_safe else "THREAT"
    print(f"{status}: {prompt[:30]}...")

​
Context Manager

Use as context manager for proper resource cleanup: 
from raxe import Raxe

with Raxe() as raxe:
    result = raxe.scan("Hello")
    # Resources automatically cleaned up

​
AsyncRaxe

Async client for high-throughput scenarios.

​
Constructor

from raxe import AsyncRaxe

raxe = AsyncRaxe(
    api_key: str | None = None,
    use_ml: bool = True,
    timeout: float = 30.0,
    config_path: str | None = None,
)
Same parameters as Raxe.

​
scan()

Async scan of a single prompt. 
async def scan(
    self,
    prompt: str,
    *,
    use_ml: bool | None = None,
    timeout: float | None = None,
) -> ScanResult
Example: 
from raxe import AsyncRaxe

async def check_prompt(prompt: str):
    async with AsyncRaxe() as raxe:
        result = await raxe.scan(prompt)
        return result.is_safe

​
scan_batch()

Async batch scanning with concurrency control. 
async def scan_batch(
    self,
    prompts: list[str],
    *,
    concurrency: int = 10,
    use_ml: bool | None = None,
    timeout: float | None = None,
) -> list[ScanResult]
Parameters:
ParameterTypeDefaultDescription
promptslist[str]requiredList of texts to scan
concurrencyint10Max concurrent scans
use_mlbool | NoneNoneOverride ML setting
timeoutfloat | NoneNoneOverride timeout
Example: 
from raxe import AsyncRaxe

async def scan_many(prompts: list[str]):
    async with AsyncRaxe() as raxe:
        # Scan up to 20 prompts concurrently
        results = await raxe.scan_batch(
            prompts,
            concurrency=20
        )
        return results

​
close()

Explicitly close the client and flush telemetry. 
async def close(self) -> None
Example: 
raxe = AsyncRaxe()
try:
    result = await raxe.scan("Hello")
finally:
    await raxe.close()

​
Context Manager

Recommended usage: 
async with AsyncRaxe() as raxe:
    result = await raxe.scan("Hello")
    # Automatically closed and flushed

​
Properties

Both Raxe and AsyncRaxe expose these properties:
PropertyTypeDescription
api_keystrCurrent API key
use_mlboolML detection enabled
timeoutfloatDefault timeout
versionstrRAXE version
Example: 
raxe = Raxe()
print(f"RAXE version: {raxe.version}")
print(f"ML enabled: {raxe.use_ml}")

​
Thread Safety

  • Raxe is thread-safe for concurrent scans
  • AsyncRaxe is safe for concurrent async tasks
  • Both clients maintain internal connection pools
import threading
from raxe import Raxe

raxe = Raxe()

def scan_thread(prompt):
    result = raxe.scan(prompt)  # Thread-safe
    return result.is_safe

threads = [
    threading.Thread(target=scan_thread, args=(f"prompt {i}",))
    for i in range(10)
]

for t in threads:
    t.start()
for t in threads:
    t.join()