Skip to main content
Yasumu’s REST client provides comprehensive HTTP/HTTPS request capabilities with a modern interface for designing, testing, and debugging API workflows. All REST entities are stored as .ysl files in your workspace, making them version-controllable and shareable.

​
Supported HTTP methods

The REST client supports all standard HTTP methods:

GET

Retrieve data from a server

POST

Submit data to create new resources

PUT

Update existing resources completely

PATCH

Partially modify existing resources

DELETE

Remove resources from the server

OPTIONS

Discover allowed methods for a resource

HEAD

Retrieve headers without response body

​
Request configuration

​
URL and parameters

Configure your request URL with support for dynamic path parameters and query strings: 
// Path parameters - use :parameter syntax
https://api.example.com/users/:userId/posts/:postId

// Query parameters are managed separately
// Enable/disable individual parameters without deleting them
Yasumu provides three types of parameters:
  • Path parameters: Dynamic segments in the URL path (e.g., :userId)
  • Query parameters: Key-value pairs appended to the URL (e.g., ?page=1&limit=10)
  • Request parameters: Values that replace path parameters in the final URL
Each parameter can be individually enabled or disabled, allowing you to quickly test different configurations without losing your setup.

​
Headers

Add custom headers to your requests using a tabular interface: 
// Common headers
Content-Type: application/json
Authorization: Bearer {{token}}
X-API-Key: {{apiKey}}
Headers support:
  • Enable/disable individual headers
  • Environment variable interpolation with {{variable}} syntax
  • Common header suggestions and autocomplete

​
Request body

Yasumu supports multiple body types for your requests: 
{
  "name": "John Doe",
  "email": "[email protected]",
  "role": "{{userRole}}"
}
JSON bodies include syntax highlighting and validation.

​
Response handling

Yasumu captures and displays complete response information:

​
Response data

  • Status code: HTTP status code with description
  • Response time: Request duration in milliseconds
  • Response size: Total size of the response body
  • Headers: All response headers in a readable format
  • Body: Formatted response body with syntax highlighting

​
Response body formatting

The response viewer automatically formats content based on the Content-Type header:
  • JSON responses are prettified with syntax highlighting
  • HTML responses can be previewed or viewed as source
  • XML responses are formatted for readability
  • Images are displayed inline
  • Text responses are shown with proper encoding
Response data is cached locally, allowing you to review previous responses without re-executing the request.

​
Entity organization

REST requests can be organized using folders (entity groups): 
// Create hierarchical structure
workspace/
  yasumu/
    rest/
      auth/
        login.ysl
        register.ysl
      users/
        get-user.ysl
        update-user.ysl
        delete-user.ysl
The REST module provides:
  • Tree view: Hierarchical display of all requests and folders
  • Drag and drop: Reorganize requests by dragging between folders
  • Quick search: Find requests by name or method
  • Filtering: Filter by HTTP method or folder

​
Request history

Yasumu automatically maintains a history of executed requests:
rest.ts:137-153
// History is tracked per entity
public async listHistory(): Promise<EntityHistoryData[]>
public async upsertHistory(entityId: string): Promise<EntityHistoryData>
  • View previously executed requests with their parameters
  • Compare responses across different executions
  • Quickly re-run historical requests
  • History is workspace-specific and persists across sessions

​
API reference

The REST module exposes a programmatic API for automation: 
const request = await workspace.rest.create({
  name: "Get User",
  method: "GET",
  url: "https://api.example.com/users/:id",
  groupId: folderId, // optional
});

​
File format

REST entities are stored as .ysl files with the following structure:
rest.schema.ts:10-35
@rest

metadata {
  name "Get User Profile"
  method "GET"
  id "unique-id"
  groupId "folder-id"
}

request {
  url "https://api.example.com/users/:userId"
  headers [
    { key "Authorization" value "Bearer {{token}}" enabled true }
  ]
  parameters [
    { key "userId" value "123" enabled true }
  ]
  searchParameters [
    { key "include" value "profile,settings" enabled true }
  ]
  body {
    type "json"
    content "{\"data\": \"value\"}"
  }
}

dependencies []

script {
  // Pre-request and post-response scripts
}

test {
  // Test automation scripts
}
The .ysl format is human-readable and git-friendly, making code reviews and collaboration seamless.

Build docs developers (and LLMs) love

Get started for freeTalk to us