Can you post the actual query that you are executing (the .net part). It seems like query lookup fails as you get an empty 'q' parameter in the urls.

/Henrik 

This is how the query is built up (Pretty complicated)

public SearchResult<OtherSearchResultItem> SearchOther(string query, int take = 20, int skip = 0, string orderBy = "", string sortOrder = "asc")
        {
            var key = string.Format("SearchOther_q:{0}_t:{1}_s:{2}_o:{3}_so:{4}", query, take, skip, orderBy, sortOrder);

            var result = CacheManager.Get(key);
            if (result != null)
            {
                return (SearchResult<OtherSearchResultItem>)result;
            }


            var totalStopWatch = new Stopwatch();
            totalStopWatch.Start();

            var returnSearchResult = new SearchResult<OtherSearchResultItem>();

            try
            {
                var searchQuery = SearchClient.Instance.UnifiedSearchGraspingRightHandTruncationFor(query,
                                                                                                    Language.Swedish)
                                                .Filter(f => !f.MatchType(typeof (EducationInfoToIndex)))
                                                .Filter(f => !f.MatchType(typeof (Jobbannons)))
                                                .Filter(f => !f.MatchType(typeof (OfficeInfoToIndex)))
                                                .Filter(f => !f.MatchType(typeof (ContactPersonToIndex)))
                                                .TermsFacetFor(x => x.SearchTypeName, x => { x.Size = 200; });
               var searchResult = searchQuery.Skip(skip).Take(take).Track().StaticallyCacheFor(TimeSpan.FromSeconds(60)).GetResult();

                returnSearchResult = new SearchResult<OtherSearchResultItem>
                    {
                        TotalCount = searchResult.TotalMatching,
                        ResultItems = searchResult.Hits.Select(h => new OtherSearchResultItem()
                            {
                                Title = h.Document.Title,
                                OtherType = TranslateTypeName(h.Document.TypeName),
                                Description = h.Document.Excerpt,
                                LinkUrl = h.Document.Url,
                                CssClass = h.Document.FileExtension
                            }).ToList(),
                        Facets = new List<FilterFacet>
                            {
                                new FilterFacet()
                                    {
                                        Name = "Typ",
                                        Terms =
                                            searchResult.TermsFacetFor(t => t.SearchTypeName)
                                                        .Terms.Select(
                                                            t =>
                                                            new FilterTerm()
                                                                {
                                                                    Name = TranslateTypeName(t.Term),
                                                                    TotalCount = t.Count
                                                                }).OrderBy(x => x.Name)
                                                        .ToList()
                                    },
                            }
                    };

                if (take == 1000 && searchResult.TotalMatching > 1000)
                {
                    var nextBatchFrom = 1000;
                    while (nextBatchFrom < searchResult.TotalMatching)
                    {
                        searchResult = searchQuery.Skip(nextBatchFrom).StaticallyCacheFor(TimeSpan.FromSeconds(60)).GetResult();
                        returnSearchResult.ResultItems.AddRange(
                            searchResult.Hits.Select(h => new OtherSearchResultItem()
                                {
                                    Title = h.Document.Title,
                                    OtherType = h.Document.TypeName,
                                    Description = h.Document.Excerpt,
                                    LinkUrl = h.Document.Url.ToLowerInvariant(),
                                    CssClass = h.Document.FileExtension
                                }));
                        nextBatchFrom += 1000;
                    }
                }


            }
            catch (Exception exception)
            {
                _logger.Error("EPiServer Find ligger nere", exception);
            }

            totalStopWatch.Stop();

            CacheManager.RuntimeCacheInsert(key, returnSearchResult, null, DateTime.Now.AddMinutes(Helpers.Constants.OtherSearchCacheTimeToLive), Cache.NoSlidingExpiration);

            return returnSearchResult;
           

        }

The function UnifiedSearchGraspingRightHandTruncationFor looks like this:

public static class SearchExtensions
    {

        public static IQueriedSearch<ISearchContent> UnifiedSearchGraspingRightHandTruncationFor(this IClient client, string query, Language language)
        {
            language = language ?? Language.None;
            return client.Search<ISearchContent>(language).GraspingRightHandTruncationFor<ISearchContent>(query).WithAndAsDefaultOperator().InAllField();
        }

        public static IQueriedSearch<TSource, QueryStringQuery> GraspingRightHandTruncationFor<TSource>(this ITypeSearch<TSource> search, string queryString)
        {
            if (search == null)
            {
                throw new ArgumentNullException("search");
            }
            
            var str = (string.IsNullOrWhiteSpace(queryString) ? "" : queryString);

            str += !str.Contains("\"") ? "*" : "";

            return new Search<TSource, QueryStringQuery>(search, (ISearchContext context) =>
            {
                var queryStringQuery = new QueryStringQuery(str);
                queryStringQuery.RawQuery = queryString;
                var queryStringQuery1 = queryStringQuery;
                context.RequestBody.Query = queryStringQuery1;
            });
        }
    }

I hope the grasping would be built in the product soon (we come from SiteSeeker and it exists there, so the customer needed to keep it)

I have now removed my extension with the grasping so now I do not get the error and it works for the unified search.

I have just published a blog post on how to do this for more than just unified search:

http://world.episerver.com/blogs/Henrik-Fransas/Dates/2015/2/how-to-do-custom-query-and-click-tracking-with-episerver-find/