Areas we Cover
Effective Pest Solutions are based in Mitcham but cover the whole of Surrey and South West London. We are dedicated to providing professional, reliable, and eco-friendly pest control services to both residential and commercial clients.
With years of experience in the industry, our highly trained team of BPCA experts is well-equipped to handle a wide range of pest problems, including rodents, insects, and birds.
We pride ourselves on using safe and sustainable methods, ensuring the wellbeing of our clients, their properties, and the environment. Our commitment to exceptional customer service and delivering lasting results has made us the go-to choice for countless customers seeking effective pest management solutions.
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