Graduate Universities

Explore UK universities below or take our new Find Your UK University Quiz to quickly find the best matches for you!

Search Graduate Universities

Academic matches are based on minimum US entry requirements.

Relevant work experience may benefit your application depending on the programme/university, especially if you have a low GPA. GRE’s are not required for UK admission. GMAT’s may be required for MBA programmes.

Royal Holloway University of London

Royal Holloway, University of London, is ranked in the top 30 universities in the UK (The Guardian University League Table, 2023). As one of the UK’s leading research-intensive universities we are home to some of the world’s foremost authorities in the sciences, arts, business, economics and law.

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