Request

HTTP Request API reference for accessing request data in AdonisJS

The Request class provides access to HTTP request data including headers, query parameters, request body, uploaded files, and cookies.

Importing

import { HttpContext } from '@adonisjs/core/http'

export default class UsersController {
  async index({ request }: HttpContext) {
    // Access request
  }
}

Properties

url · string

The complete URL of the request

method · string

HTTP method (GET, POST, etc.)

id · string

Unique identifier for the request

ctx · HttpContext

Reference to the HTTP context

URL and Path

url()

Get the complete URL including query string.

const url = request.url()
// Returns: '/posts?page=1&limit=10'

withQueryString · boolean · default: "false"

Include query string in the URL

Returns: string

completeUrl()

Get the complete URL with protocol and host.

const url = request.completeUrl()
// Returns: 'https://example.com/posts?page=1'

withQueryString · boolean · default: "false"

Include query string in the URL

Returns: string

pathname()

Get the URL pathname without query string.

const path = request.pathname()
// Returns: '/posts'

Returns: string

protocol()

Get the request protocol (http or https).

const protocol = request.protocol()
// Returns: 'https'

Returns: string

hostname()

Get the request hostname.

const host = request.hostname()
// Returns: 'example.com'

Returns: string

host()

Get the request host including port.

const host = request.host()
// Returns: 'example.com:3333'

Returns: string

Query Parameters

qs()

Get all query string parameters.

const params = request.qs()
// Returns: { page: '1', limit: '10' }

Returns: Record<string, any>

input()

Get a specific query parameter value.

const page = request.input('page')
const limit = request.input('limit', 20) // with default

key · string

Parameter name

defaultValue · any

Default value if parameter is not present

Returns: any

Request Body

all()

Get all request body data.

const data = request.all()
// Returns: { name: 'John', email: '[e-mail]' }

Returns: Record<string, any>

body()

Get the entire request body.

const body = request.body()

Returns: Record<string, any>

only()

Get specific fields from the request body.

const data = request.only(['name', 'email'])
// Returns: { name: 'John', email: '[e-mail]' }

keys · string[]

Array of field names to extract

Returns: Record<string, any>

except()

Get all fields except specified ones.

const data = request.except(['_csrf', 'password_confirmation'])

keys · string[]

Array of field names to exclude

Returns: Record<string, any>

Route Parameters

params()

Get all route parameters.

// Route: /posts/:id
const params = request.params()
// Returns: { id: '42' }

Returns: Record<string, any>

param()

Get a specific route parameter.

const id = request.param('id')

key · string

Parameter name

defaultValue · any

Default value if parameter is not present

Returns: any

Headers

headers()

Get all request headers.

const headers = request.headers()

Returns: Record<string, string>

header()

Get a specific header value.

const authHeader = request.header('authorization')
const userAgent = request.header('user-agent', 'unknown')

key · string

Header name (case-insensitive)

defaultValue · any

Default value if header is not present

Returns: string | undefined

Cookies

cookie()

Get a cookie value.

const sessionId = request.cookie('session_id')

key · string

Cookie name

defaultValue · any

Default value if cookie is not present

Returns: any

plainCookie()

Get a plain (unsigned) cookie value.

const value = request.plainCookie('tracking_id')

key · string

Cookie name

defaultValue · any

Default value if cookie is not present

Returns: any

encryptedCookie()

Get an encrypted cookie value.

const value = request.encryptedCookie('sensitive_data')

key · string

Cookie name

defaultValue · any

Default value if cookie is not present

Returns: any

cookiesList()

Get all cookies as an object.

const cookies = request.cookiesList()

Returns: Record<string, any>

File Uploads

file()

Get an uploaded file.

const avatar = request.file('avatar', {
  size: '2mb',
  extnames: ['jpg', 'png', 'jpeg']
})

if (avatar) {
  await avatar.move('uploads')
}

key · string

Form field name

options · FileValidationOptions

Validation options for the file

• size: Maximum file size
• extnames: Allowed file extensions

Returns: MultipartFile | null

files()

Get multiple uploaded files.

const images = request.files('images', {
  size: '5mb',
  extnames: ['jpg', 'png']
})

for (const image of images) {
  await image.move('uploads')
}

key · string

Form field name

options · FileValidationOptions

Validation options for the files

Returns: MultipartFile[]

allFiles()

Get all uploaded files.

const files = request.allFiles()

Returns: Record<string, MultipartFile | MultipartFile[]>

Content Type

is()

Check if the request has a specific content type.

if (request.is(['json', 'application/json'])) {
  // Handle JSON request
}

types · string[]

Array of content types to check

Returns: string | boolean

types()

Get acceptable content types from the Accept header.

const types = request.types()
// Returns: ['application/json', 'text/html']

Returns: string[]

accepts()

Check if the request accepts a specific content type.

if (request.accepts(['html', 'json']) === 'json') {
  return response.json({ data })
}

types · string[]

Array of content types to check

Returns: string | boolean

Request Validation

validateUsing()

Validate request data using a VineJS validator.

import { createUserValidator } from '#validators/user'

const data = await request.validateUsing(createUserValidator)

validator · VineValidator

VineJS validator instance

options · RequestValidationOptions

Optional validation options

• errorReporter: Custom error reporter
• messagesProvider: Custom messages provider
• data: Custom data to validate (defaults to request data)

Returns: Promise<T>

tryValidateUsing()

Validate request data without throwing errors.

const [error, data] = await request.tryValidateUsing(createUserValidator)

if (error) {
  return response.badRequest(error.messages)
}

validator · VineValidator

VineJS validator instance

options · RequestValidationOptions

Optional validation options

Returns: Promise<[ValidationError, null] | [null, T]>

Utilities

fresh()

Check if the request is fresh (for caching).

if (request.fresh()) {
  response.notModified()
}

Returns: boolean

stale()

Check if the request is stale.

if (request.stale()) {
  // Regenerate content
}

Returns: boolean

ajax()

Check if the request is an AJAX request.

if (request.ajax()) {
  return response.json({ data })
}

Returns: boolean

pjax()

Check if the request is a PJAX request.

if (request.pjax()) {
  // Handle PJAX
}

Returns: boolean

secure()

Check if the request is over HTTPS.

if (!request.secure()) {
  return response.redirect(`https://${request.host()}${request.url()}`)
}

Returns: boolean

ip()

Get the client IP address.

const ip = request.ip()

Returns: string

ips()

Get all IP addresses from X-Forwarded-For header.

const ips = request.ips()

Returns: string[]

subdomains()

Get request subdomains.

const subdomains = request.subdomains()
// For 'blog.example.com': ['blog']

Returns: string[]

Example Usage

import { HttpContext } from '@adonisjs/core/http'
import { createUserValidator } from '#validators/user'

export default class UsersController {
  async store({ request, response }: HttpContext) {
    // Validate request
    const data = await request.validateUsing(createUserValidator)
    
    // Access specific fields
    const email = request.input('email')
    const { name, email } = request.only(['name', 'email'])
    
    // Handle file upload
    const avatar = request.file('avatar', {
      size: '2mb',
      extnames: ['jpg', 'png']
    })
    
    if (avatar) {
      await avatar.move('uploads')
    }
    
    // Check request type
    if (request.ajax()) {
      return response.json({ success: true })
    }
    
    return response.redirect('/users')
  }
}