Fiddler’s Performance Roots

In 2003, I began developing the Fiddler Web Debugger to help debug client-server interactions between Office 2003 and the Office Online website. At first, my goal was to simplify functional testing, but when the Office Online website went live, we immediately found we had major performance issues, and Fiddler was soon pressed into service to help analyze these problems.

Our website suffered from numerous backend scalability problems, but we found that even when the site was under light load, page load times were nowhere near our goals. The problems were myriad—the site wasn’t using compression in enough places, most resources weren’t cacheable, and pages often used dozens of small resources from multiple different domains. A misunderstanding of ASP.NET postbacks led to uploading ~100kb of uncompressed data when users clicked the “Terms of use” checkbox—an upload operation that could take multiple seconds on then-common DSL connections, and (torturously) even longer on a modem.

Using Fiddler, the team began discovering and attacking each of these problems, and I soon had a long queue of feature requests to enhance Fiddler’s usefulness as a performance-optimization tool.

Measurement vs. Optimization

I’m often asked “How do I measure my site’s page load performance using Fiddler?” My typical answer is “You’re using it wrong. Use a stopwatch to measure time; use Fiddler to learn how to make your site faster.

Fiddler operates as a proxy server between your client and the websites you’re testing. As a consequence, it must be recognized that Fiddler introduces Observer Effects, whereby the observed performance can differ from the real-world performance due to the measurement tool alone. This was particularly true in the dark days of IE6 and IE7, where WinINET limited the connections-per-proxy to two.

Now, that’s not to say that performance measurements with Fiddler are invalid—simply that they must be considered in the appropriate context. For instance, some percentage of a site’s visitors will be behind a proxy server of some sort, and most sites’ visitors have a broad range of bandwidth, latency, and CPU performance.

For most web developers, the measurement limitations of debugging proxies are not very important—the optimization opportunities you can discover with Fiddler are usually orthogonal to observer effects that affect measurement. For instance, Fiddler reliably shows request and response size, caching directives, compression information, socket reuse, and myriad other crucial information for performance optimization.

Use the Platform

Even as I raced to add features to Fiddler to better meet my team’s needs, I recognized that there were many scenarios (e.g. security testing, content archiving, behavioral logging, prototyping) where I couldn’t possibly keep up with the feature requests. As a consequence, I invested heavily in architecting Fiddler as a platform, where the full power of Fiddler was exposed to developers using both scripting (FiddlerScript is based on JScript.NET, an ECMAScript dialect) and .NET assemblies written in C#, VB.NET, or any .NET language. Subject-matter-experts have built and shared a number of powerful extensions atop Fiddler, and many teams have built lightweight bespoke add-ons to address their own scenarios.

For example, the Microsoft ACE team built neXpert, a Performance-best-practices analyzer which generates a report of how closely your site adheres to common best-practices.

A number of years after Fiddler was first released, there were a flurry of requests of the form: “How do I put Fiddler inside my automated test harness or application… with none of the UI?” These requests led to the release of FiddlerCore, a class library that can be used to integrate the core functionality of Fiddler into any .NET application. Some consumers of this library use it to maintain a daily database archive of the metrics for their site (e.g. page weight, resource/domain count, etc) so they can understand how their site’s key performance metrics have evolved over time. At Telerik, we use this library to capture test cases for TestStudio, our functional and load testing suite.


While I was (and remain) eager to encourage the community to build atop the Fiddler object model, I recognized that developers have many tools in their toolboxes, and no tool should be an island.

Fiddler includes a rich Import/Export model that enables interop with other web tools. Fiddler can import and export traffic captures in the standard HTTPArchive format as well as the XML-based variant exported from IE9 and IE10. You can also easily export HTML5 AppCache Manifests to simplify your site’s adoption of this performance-enhancing technology.

Tool developers can easily build and share their own importers or exporters, or adopt the simple SAZ Format that Fiddler natively uses to losslessly store web traffic.

Improve Performance with 10 Fiddler Tricks

Fiddler is a useful tool in many performance-optimization scenarios. Following are 10 tips that will help get you started.

1. Work with DataURIs

DataURIs allow you to embed small resources directly within your page. Unfortunately, as long strings of base64-encoded binary, these resources can be somewhat more difficult to work with than the individual resource files they replace.

With Fiddler, you can copy a DataURI to your clipboard (from Fiddler itself, or anywhere else):

Then use the Edit > Paste Files as Sessions command to instruct Fiddler to parse the DataURI and create a new Session for it:

You can then use Fiddler’s Inspectors to examine the resulting object:

You can also easily create new DataURIs with Fiddler. Simply right-click one or more Sessions in the Web Sessions list and click the Copy > Response DataURI command on the context menu. The responses’ bodies will be encoded as DataURIs and copied to your clipboard. You can then inline these resources into whatever page you like.

2. Find Slow Pages with the Heat Map

Fiddler maintains a Timers object for each Web Session to enable you to understand how much time was spent on the request and response. You can easily visualize this timing data using the Time HeatMap checkbox inside the Response Time and Size section on Fiddler’s Filters tab.

When enabled, Fiddler sets a background color for each Session based on how long the server took to return a given response completely. Responses that take less than 50 milliseconds show in shades of green. Responses that take between 50 and 300 milliseconds are not colored. Responses that take between 300 and 500 milliseconds show in yellow. Responses that take more than 500 milliseconds show in shades of red.

3. Use the Timeline

By default, Fiddler’s Timeline tab shows a traditional waterfall chart to visualize the download of the Web Sessions you’ve selected. Each transfer line shows the start of the request and conclusion of the response. The small circles before the bar indicate whether the client and server connections were reused:

(Be sure to enable Streaming Mode when capturing, or you’ll find that your chart looks more like stair-steps than a waterfall.)

Beyond the default waterfall, Fiddler offers two other modes, Client Map and Server Map that allow you to visualize connection reuse between the client and the server, by displaying all transfers for a given connection on a single row. For instance, the following chart shows good connection reuse:

In contrast, if the server were misconfigured to close connections after each response, each row would show only one transfer.

4. Simulate Zero Network / Backend Time

Fiddler’s AutoResponder allows you to “play back” previously captured responses from within Fiddler. By unchecking the Enable Latency box, you can simulate an “infinitely fast” connection and server:

When so configured, Fiddler will immediately return a previously-captured response for every request from the client without hitting the network or the real server. In this way, you can determine the lower-bound for page load time—your pages will never load faster than this!

If you find that your site isn’t meeting your performance goals with an infinitely-fast network, you will need to optimize your clientside code (JavaScript, DOM operations).

5. Expose Compression Information in a Column

Fiddler’s Web Sessions list exposes a great deal of information, but often you may find yourself wishing that it showed even more information. For instance, what if you’d like to easily see which responses were compressed?

There are many ways to add new columns to Fiddler, but for a simple scenario like this, the easiest is to just type the following command in the QuickExec box beneath the Web Sessions list:

cols add Encoding @Response.Content-Encoding

After you’ve done so, a new “Encoding” column appears in the Web Sessions list. As new Web Sessions are captured, the column is filled with the contents of each response’s Content-Encoding header.

To fill in the new column’s rows for previously-captured Sessions, simply hit CTRL+A to select them all, then hit the F5 key.

6. Select Sessions Based on a Column’s Contents

Say you’d like to quickly get a list of HTTP Responses which are configured with a no-cache directive in their Cache-Control header. Simply right-click the column and choose Search this column….

You can search using exact text, a regular expression, or greater-than or less-than expressions.

7. Use QuickExec to Find Sessions

The QuickExec box beneath the Web Sessions list is often the fastest way to find traffic that matches simple criteria.

  • To select all responses greater than 25000 bytes, type: >25k and hit Enter.
  • To find all responses that returned a status code of 404, type: =404 and hit Enter.
  • To find all requests targeted at a server with the text “ad.” in the hostname, type: @ad. and hit Enter.
  • To find all requests that returned HTML, type: select text/html and hit Enter.
  • To find all requests that were sent with a no-cache pragma, type: select @Request.Pragma no-cache and hit Enter.

8. Beautify JavaScript

Minifying JavaScript is a performance best-practice, but crunched script can be very difficult to debug. You can use Fiddler’s JSFormat or SyntaxView extensions to quickly beautify JavaScript code for easier reading. For instance, this:

…can be formatted much more readably as:

You have the option of simply formatting the script for display in Fiddler, or also formatting the script returned to the client (useful if you’re using an in-browser script debugger).

Alternatively, Fiddler can also replace script files entirely, on-the-fly. For instance, JQuery.js is available in both minified and debug versions. You can easily use Fiddler’s AutoResponder to replace the request for the minified version of the JS file with the debug version of the script. This way, you can easily debug your production site without slowing down performance for other users.

9. Leverage FiddlerScript Rules

On Fiddler’s Rules menu, you’ll find the following options:

  • Simulate Modem Speeds delays each outbound request and inbound response by throttling the rate at which content is written to and read from the network.
  • Disable Caching removes all conditional validation headers from requests and rewrites all responses to Cache-Control: no-cache.
  • Show Time-to-Last-Byte displays the number of milliseconds that it took to receive the entire response in the Web Sessions list’s Custom column. Similarly, Show Response Timestamp shows the timestamp at which the server’s response was completely received by Fiddler in that column.
  • The Cache Always Fresh option will automatically respond to any conditional HTTP request with a HTTP/304 response indicating that the client’s cache is up-to-date, preventing the request to the server. You can use this option to explore the performance improvement of specifying a proper cache freshness lifetime.

These rules are implemented in FiddlerScript and can be easily viewed (and modified) by pressing Ctrl+R or clicking the Customize Rules… command on the Rules menu.

10. Write Your Own FiddlerScript Rules

Patrick Meenan mentioned that WebPageTest recently added a rule to check every uncompressed response and flag if a 10% savings would be realized if compression were present. You can easily do something like this in Fiddler.

Click the Customize Rules… command on the Rules menu to open the Fiddler Rules file. Scroll to OnBeforeResponse and add the following code inside that function:

if (!oSession.oResponse.headers.Exists("Content-Encoding") &&
     !oSession.oResponse.headers.Exists("Transfer-Encoding") &&
     (null != oSession.responseBodyBytes))
     var iCurrentSize:int = oSession.responseBodyBytes.Length;
     var iCompressedSize:int =
     if (iCurrentSize > (iCompressedSize*1.1))
         oSession["ui-backcolor"] = "#FF8E8E";
         oSession["ui-customcolumn"] = "Compression would save "
             + (iCurrentSize - iCompressedSize).ToString() + " bytes.";

Now, as you navigate around the web, you’ll see Sessions flagged in red if the response body would be at least 10% smaller when GZipped:

What’s Next for Fiddler

Now that I’m working on Fiddler full-time for Telerik, I’ve had the opportunity to make some long-awaited tweaks and embark on some major new feature work.

This week, I’m working on full support for viewing/fiddling with HTML5 WebSocket messages. I’m also working on a CSS Beautifier (like the JS beautifier mentioned above) and tuning Fiddler’s own performance.

Up next, I’m hoping to get started on a much-improved bandwidth simulation module (with both better fidelity and more options than the current Simulate Modem Speeds option) while I work with the design team on an overhaul of the Fiddler user-experience. I’ll also be working to get Fiddler working even better across devices, especially mobile platforms (iOS, WindowsPhone, and Android).

Longer-term, there are two features I’m starting to think about: PCAP import (view your NetMon and WireShark-captured traffic in Fiddler’s UI), and SPDY capture. Support for SPDY is likely to prove especially tricky because the current version of the protocol depends on NPN, a TLS extension which is not currently supported by any version of Windows’ SChannel HTTPS stack.

What would you like to see next in Fiddler?


Eric Lawrence (@ericlaw) spent eight years as a Program Manager on the Internet Explorer team at Microsoft. In the fall of 2012, he left Microsoft to develop Fiddler full-time at Telerik. His book on Fiddler is now available in both paperback and PDF formats.

17 Responses to “Building Faster Sites and Services with Fiddler”

  1. Robert

    1.One of the great features of fiddler is how easy it is to use out of the box for even novice users. In adding more features please do not lose this.

    2. A feature to save the current state of all menu check items and settings in filters and other tabs to a named fiddler settings file. As I find more uses for fiddler I find myself forgetting to check certain items when I am doing a particular type of debugging. As you add more features being able to load fiddlers settings file to configure fiddle a certain way would be useful.

    3. Add ability to have multiple fiddler script files that get loaded. This would allow a developer to have there enhancement in their own file so that upon new releases of fiddler it is not as difficult to merge customizations with the script shipped with fiddler. Personally I have move my customizations to assemblies for this reason. Also this would allow a better organization of changes and allow easier sharing among developers as they could just drop additional script files in the folder.

    4. Enable the loading of extensions from custom assemblies to use the attributes available in fiddler script to create menu items and add colmuns. This would simplify extension creation.

  2. EricLaw

    Thanks for the great suggestions, Robert!

    1> Absolutely. Improving ease-of-use is a key goal, even as the tool gains power. Over the past month, I’ve resolved some key longstanding problems that made Fiddler tough for novices, and I hope to do more shortly.

    2> Fiddler’s Preference system was the first step in this process ( At some point, I hope to pivot this to support “profiles”, so you can have grouped sets of preferences that switch on demand. This will be a powerful feature, but needs a lot of work to ensure that it’s not confusing and works well.

    3> At the base, this is a trivial feature request (a few lines of code). However, it quickly gets very complicated if you start to consider cross-script-file interactions. If the script files are entirely independent (e.g. no shared variables or state or whatnot) then this wouldn’t be too hard. There’s a bit of potential ecosystem impact, however, since the current script-related events all presume a single script instance. I’ll have to ponder this some more.

    4> You might want to check out the Fiddler book– it’s quite simple to add both columns and menu items from Fiddler extensions. I’ll probably do a bit of work to make it even simpler to add menu items (akin to the current attribute system used by script) but it’s not difficult. If you’re having a specific problem getting this to work, please give me a shout in the forums; just click Help > Fiddler Community Discussions.


  3. Srikanth

    Can we set the DNS mapping in the fiddler. Something like hosts file does. Usecase: During development i would like one of my browser to talk to dev boxes.

  4. Saffron X

    You really make it seem so easy together with your presentation however I
    in finding this topic to be really something that I feel I’d by no means understand. It sort of feels too complex and very wide for me. I am having a look ahead in your next submit, I’ll attempt to get the hang of it!

  5. Daniel

    Hi – We are testing web applications from various low bandwidth, high latency sites around the world. I wonder if it is possible to change the heatmap values so that they change colors for higher values – for example, increasing the values to start turning red after 15 seconds. Some of our sites have such challenging connectivity, that we need to set our standards a bit lower.

    Thanks for your help!


  6. Eric Lawrence

    @Srikanth: Of course. Click Tools > HOSTS.

    @Daniel: You can use FiddlerScript for this; just set the ui-backcolor property on the session based on the data contained in the Session’s Timers object.

  7. Kamal


    Amazing work you’ve done for thousands of performance engineers in the world. I do not have any suggestions for improvement of Fiddler so far as I am already overwhelmed with the useful information fiddler provides to us without any cost.

    Worth every sec of your hard and smart work to develop Fiddler..

  8. Ravi

    Hi Eric,

    Can we capture and save the network capture automatically? How do we compare the earlier saved capture? Do we have any support for it?

    Use Case:
    I just want to run certain steps on my application.
    I would like to repeat same steps again and see if there is any difference on both requests?

  9. Ravi


    Would it be possible to trim request/response not to have starting strings (Some junk or unwanted information)?
    V s aVD
    ProcessRequestXmlResponse�T …
    I just want to have response starts with ….

  10. Soorj

    Hi Eric,

    Is there a way we can automate fiddler, to send the same request multiple times, like a web performance test in Visual Studio. thus we could then collect the average time taken for each of the requests.

  11. personalized gift

    What’s up everyone, it’s my first pay a visit at this
    web page, and article is really fruitful in support of me, keep up posting these posts.

  12. Lucile

    Great blog you’ve got here.. It’s hard to find high-quality writing like yours nowadays.
    I honestly appreciate people like you! Take care!!

  13. Fiddler2 to the max: inserting proxy authentication to use DropBox (or other app) behind a corporate firewall « The Wiert Corner – irregular stream of stuff

    […] Eric Lawrence (the Fiddler author) has written numerous interesting Fiddler articles. For instance this one. […]

  14. オロビアンコ バッグ

    Hello, I think your site might be having browser compatibility issues.

    When I look at your blog site in Chrome, it looks fine
    but when opening in Internet Explorer, it has some overlapping.
    I just wanted to give you a quick heads up! Other then
    that, fantastic blog!

  15. real twitter

    My brother recommended I might like this blog. He was totally
    right. This post truly made my day. You can not imagine simply
    how much time I had spent for this information!

  16. car

    It is very simple to upgrade a car in your car lease options,
    the only thing that you will need is a down payment or deposit for your current that you will make
    to your auto lease company. Also, don’t believe it if the sales person says, “If you don’t buy this car today, it will be gone tomorrow. Depending on what type of vehicle you buy, expect to pay $150 to $200 for an auto maintenance contract.

  17. lavazza mexican black beans and rice

    Water, machine quality, grind, tamp pressure, and water temperature all play
    a vital role in the production of perfect espresso. With lobster tails you can prepare varieties of dishes; however, if you want to keep
    it simple then you can simply bake them. The Handpresso Wild Hybrid is the latest hand pump
    espresso maker where you only need a way to heat up water to get espresso wherever you happen to

Leave a Reply

You can use these tags: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <strike> <strong>
And here's a tool to convert HTML entities