Apache mod_rewrite Flags - Apache HTTP Server

Apache HTTP Server Version 2.2

Apache > HTTP Server > Documentation > Version 2.2 > Rewrite

# Apache mod_rewrite Flags

Available Languages: en

This document discusses the flags which are available to the `RewriteRule` directive, providing detailed explanations and examples. This is not necessarily a comprehensive list of all flags available, so be sure to also consult the reference documentation.

### See also

- Module documentation
- Technical details
- Rewrite Guide - useful examples
- Advanced Rewrite Guide - advanced useful examples

## Introduction

`RewriteRule`s can have their behavior modified by one or more flags. Flags are included in square brackets at the end of the rule, and multiple flags are separated by commas.

`RewriteRule pattern target [Flag1,Flag2,Flag3]`

The flags all have a short form, such as `CO`, as well as a longer form, such as `cookie`. Some flags take one or more arguments. Flags are not case sensitive.

## The flags

Each flag has a long and short form. While it is most common to use the short form, it is recommended that you familiarize yourself with the long form, so that you remember what each flag is supposed to do.

Presented here are each of the available flags, along with an example of how you might use them.

### C|chain

The [C] or [chain] flag indicates that the `RewriteRule` is chained to the next rule. That is, if the rule matches, then it is processed as usual and control moves on to the next rule. However, if it does not match, then the next rule, and any other rules that are chained together, will be skipped.

### CO|cookie

The [CO], or [cookie] flag, allows you to set a cookie when a particular `RewriteRule` matches. The argument consists of three required fields and two optional fields.

You must declare a name and value for the cookie to be set, and the domain for which you wish the cookie to be valid. You may optionally set the lifetime of the cookie, and the path for which it should be returned.

By default, the lifetime of the cookie is the current browser session.

By default, the path for which the cookie will be valid is "/" - that is, the entire website.

Several examples are offered here:

`RewriteEngine On
RewriteRule ^/index.html - [CO=frontdoor:yes:.apache.org:1440:/]`

This rule doesn't rewrite the request (the "-" rewrite target tells mod_rewrite to pass the request through unchanged) but sets a cookie called 'frontdoor' to a value of 'yes'. The cookie is valid for any host in the `.apache.org` domain. It will be set to expire in 1440 minutes (24 hours) and will be returned for all URIs.

### E|env

With the [E], or [env] flag, you can set the value of an environment variable. Note that some environment variables may be set after the rule is run, thus unsetting what you have set. See the Environment Variables document for more details on how Environment variables work.

The following example sets an evironment variable called 'image' to a value of '1' if the requested URI is an image file. Then, that environment variable is used to exclude those requests from the access log.

`RewriteRule \.(png|gif|jpg) - [E=image:1]
CustomLog logs/access_log combined env=!image`

Note that this same effect can be obtained using `SetEnvIf`. This technique is offered as an example, not as a recommendation.

### F|forbidden

Using the [F] flag causes Apache to return a 403 Forbidden status code to the client. While the same behavior can be accomplished using the `Deny` directive, this allows more flexibility in assigning a Forbidden status.

The following rule will forbid `.exe` files from being downloaded from your server.

`RewriteRule \.exe - [F]`

This example uses the "-" syntax for the rewrite target, which means that the requested URI is not modified. There's no reason to rewrite to another URI, if you're going to forbid the request.

### G|gone

The [G] flag forces Apache to return a 410 Gone status with the response. This indicates that a resource used to be available, but is no longer available.

As with the [F] flag, you will typically use the "-" syntax for the rewrite target when using the [G] flag:

`RewriteRule oldproduct - [G,NC]`

### H|handler

Forces the resulting request to be handled with the specified handler. For example, one might use this to force all files without a file extension to be parsed by the php handler:

`RewriteRule !\. - [H=application/x-httpd-php]`

The regular expression above - `!\.` - will match any request that does not contain the literal `.` character.

### L|last

The [L] flag causes `mod_rewrite` to stop processing the rule set. In most contexts, this means that if the rule matches, no further rules will be processed.

If you are using `RewriteRule` in either `.htaccess` files or in `<Directory>` sections, it is important to have some understanding of how the rules are processed. The simplified form of this is that once the rules have been processed, the rewritten request is handed back to the URL parsing engine to do what it may with it. It is possible that as the rewritten request is handled, the `.htaccess` file or `<Directory>` section may be encountered again, and thus the ruleset may be run again from the start. Most commonly this will happen if one of the rules causes a redirect - either internal or external - causing the request process to start over.

It is therefore important, if you are using `RewriteRule` directives in one of these context that you take explicit steps to avoid rules looping, and not count solely on the [L] flag to terminate execution of a series of rules, as shown below.

The example given here will rewrite any request to `index.php`, giving the original request as a query string argument to `index.php`, however, if the request is already for `index.php`, this rule will be skipped.

`RewriteCond %{REQUEST_URI} !index\.php
RewriteRule ^(.*) index.php?req=$1 [L]`

### N|next

The [N] flag causes the ruleset to start over again from the top. Use with extreme caution, as it may result in loop.

The [Next] flag could be used, for example, if you wished to replace a certain string or letter repeatedly in a request. The example shown here will replace A with B everywhere in a request, and will continue doing so until there are no more As to be replaced.

`RewriteRule (.*)A(.*) $1B$2 [N]`

You can think of this as a `while` loop: While this pattern still matches, perform this substitution.

### NC|nocase

Use of the [NC] flag causes the `RewriteRule` to be matched in a case-insensitive manner. That is, it doesn't care whether letters appear as upper-case or lower-case in the matched URI.

In the example below, any request for an image file will be proxied to your dedicated image server. The match is case-insensitive, so that `.jpg` and `.JPG` files are both acceptable, for example.

`RewriteRule (.*\.(jpg|gif|png))$ http://images.example.com$1 [P,NC]`

### NE|noescape

By default, special characters, such as `&` and `?`, for example, will be converted to their hexcode equivalent. Using the [NE] flag prevents that from happening.

`RewriteRule ^/anchor/(.+) /bigpage.html#$1 [NE,R]`

The above example will redirect `/anchor/xyz` to `/bigpage.html#xyz`. Omitting the [NE] will result in the # being converted to its hexcode equivalent, `%23`, which will then result in a 404 Not Found error condition.

### NS|nosubreq

Use of the [NS] flag prevents the rule from being used on subrequests. For example, a page which is included using an SSI (Server Side Include) is a subrequest, and you may want to avoid rewrites happening on those subrequests.

Images, javascript files, or css files, loaded as part of an HTML page, are not subrequests - the browser requests them as separate HTTP requests.

### P|proxy

Use of the [P] flag causes the request to be handled by `mod_proxy`, and handled via a proxy request. For example, if you wanted all image requests to be handled by a back-end image server, you might do something like the following:

`RewriteRule (.*)\.(jpg|gif|png) http://images.example.com$1.$2 [P]`

Use of the [P] flag implies [L] - that is, the request is immediatly pushed through the proxy, and any following rules will not be considered.

### PT|passthrough

The target (or substitution string) in a RewriteRule is assumed to be a file path, by default. The use of the [PT] flag causes it to be treated as a URI instead. That is to say, the use of the [PT] flag causes the result of the `RewriteRule` to be passed back through URL mapping, so that location-based mappings, such as `Alias`, for example, might have a chance to take effect.

If, for example, you have an `Alias` for /icons, and have a `RewriteRule` pointing there, you should use the [PT] flag to ensure that the `Alias` is evaluated.

`Alias /icons /usr/local/apache/icons
RewriteRule /pics/(.+)\.jpg /icons/$1.gif [PT]`

Omission of the [PT] flag in this case will cause the Alias to be ignored, resulting in a 'File not found' error being returned.

### QSA|qsappend

When the replacement URI contains a query string, the default behavior of `RewriteRule` is to discard the existing query string, and replace it with the newly generated one. Using the [QSA] flag causes the query strings to be combined.

Consider the following rule:

`RewriteRule /pages/(.+) /page.php?page=$1 [QSA]`

With the [QSA] flag, a request for `/pages/123?one=two` will be mapped to `/page.php?page=123&one=two`. Without the [QSA] flag, that same request will be mapped to `/page.php?page=123` - that is, the existing query string will be discarded.

### R|redirect

Use of the [R] flag causes a HTTP redirect to be issued to the browser. If a fully-qualified URL is specified (that is, including `http://servername/`) then a redirect will be issued to that location. Otherwise, the current servername will be used to generate the URL sent with the redirect.

A status code may be specified, in the range 300-399, with a 302 status code being used by default if none is specified.

You will almost always want to use [R] in conjunction with [L] (that is, use [R,L]) because on its own, the [R] flag prepends `http://thishost[:thisport]` to the URI, but then passes this on to the next rule in the ruleset, which can often result in 'Invalid URI in request' warnings.

### S|skip

The [S] flag is used to skip rules that you don't want to run. This can be thought of as a `goto` statement in your rewrite ruleset. In the following example, we only want to run the `RewriteRule` if the requested URI doesn't correspond with an actual file.

`# Is the request for a non-existent file?
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_FILENAME} !-d
# If so, skip these two RewriteRules
RewriteRule .? - [S=2]
RewriteRule (.*\.gif) images.php?$1
RewriteRule (.*\.html) docs.php?$1`

This technique is useful because a `RewriteCond` only applies to the `RewriteRule` immediately following it. Thus, if you want to make a `RewriteCond` apply to several `RewriteRule`s, one possible technique is to negate those conditions and use a [Skip] flag.

### T|type

Sets the MIME type with which the resulting response will be sent. This has the same effect as the `AddType` directive.

For example, you might use the following technique to serve Perl source code as plain text, if requested in a particular way:

`# Serve .pl files as plain text
RewriteRule \.pl$ - [T=text/plain]`

Or, perhaps, if you have a camera that produces jpeg images without file extensions, you could force those images to be served with the correct MIME type by virtue of their file names:

`# Files with 'IMG' in the name are jpg images.
RewriteRule IMG - [T=image/jpg]`

Please note that this is a trivial example, and could be better done using `<FilesMatch>` instead. Always consider the alternate solutions to a problem before resorting to rewrite, which will invariably be a less efficient solution than the alternatives.

Available Languages: en