A visitor lands on a local business site looking for one thing: where is this place, and how do I get there? If the only clue is a street address typed out in plain text, some visitors will copy it into their own maps app — and some won’t bother. A working embedded map removes that friction, and it takes about two minutes to add. That part is genuinely simple. The two things worth knowing before you paste the code in are less commonly mentioned: the embed has a real page-speed cost, and if you’re running a site for an EU audience, it isn’t quite the no-strings-attached embed it looks like.
The Two-Minute Embed
No plugin, API key, or Google account is required for a basic embed — Google’s free Maps Embed flow generates a signed iframe URL that works on any page without further setup.
- Find the exact spot. Go to Google Maps and search the address, or drop a pin manually. For businesses in shared complexes or industrial parks, search results can land on the wrong building — drop the pin yourself rather than trusting the address match.
- Open Share, then Embed a map. The location’s info panel has a “Share” option; the embed tab sits next to the regular link-sharing tab.
- Copy the HTML snippet at whatever size fits the page layout.
- Paste it into a Custom HTML block in the WordPress editor, wherever the map should sit — usually right beside the address and opening hours on the contact page, not off on its own.
Preview the page and click through the embed once it’s live — it’s the only way to confirm the pin actually landed where you think it did. Google’s Maps Embed API documentation covers extra parameters if you want a specific zoom level or turn-by-turn directions baked into the embed itself.
The Page-Speed Cost Nobody Mentions
A live Google Maps iframe isn’t free to load — it pulls in tiles, scripts, and Google’s own map UI from their CDN the moment the page renders, on top of a browser lookup on maps.google.com. On a contact page that’s mostly text, that’s often the single heaviest thing on the page. Placed above the fold, it can drag out Largest Contentful Paint noticeably; real-world measurements on comparable embeds (YouTube iframes are the most-studied case) routinely show LCP improvements of 500–2000ms once the load is deferred.
The fix is one attribute, not a plugin: add loading="lazy" to the iframe tag Google gave you, right after the src attribute. As of 2026 this is natively supported across every browser that matters — Chrome, Firefox, Safari, and Edge all honor it, over 96% effective global coverage — so it costs nothing to add and older browsers simply ignore it and load the map eagerly, which is exactly the safe fallback you want. The browser then only fetches the map once it’s actually about to scroll into view, instead of competing with your page’s real content for bandwidth on first load.
If You’re Running This for an EU Audience, There’s a Consent Wrinkle
This is the part most “how to embed Google Maps” guides skip entirely, and it’s worth knowing rather than discovering later. The moment that iframe loads, the visitor’s browser connects directly to Google’s servers — which sets cookies and shares the visitor’s IP address with Google, before anyone has clicked or agreed to anything. Under the ePrivacy Directive and GDPR, that’s treated the same as any other non-essential third-party cookie: it needs the visitor’s active, informed consent first, not just a mention buried in a privacy policy. The Dutch Autoriteit Persoonsgegevens and other EU data protection authorities apply this same standard to embedded Google Maps that they apply to embedded YouTube videos and social share buttons — an auto-loading third-party iframe is an auto-loading third-party iframe, regardless of which company runs the server.
The practical fix is the same click-to-load pattern already common for embedded YouTube videos: show a static placeholder — a screenshot of the map, or just a labeled “Click to load map” button — and only insert the real Google iframe once the visitor actively interacts with it, ideally gated behind whatever cookie-consent state your site already tracks. That single interaction is what turns “Google set a cookie without asking” into “the visitor asked for this, and consented to what loading it involves.” It’s slightly more setup than a bare embed, but it’s the difference between a page that’s actually compliant and one that just looks fine until someone checks.
When One Pin Isn’t Enough
The embed above covers the overwhelming majority of cases: one business, one location, no ongoing maintenance. A dedicated maps plugin earns its keep only once a business has multiple branches to show on the same map, needs styled markers that match the site’s brand colors, or wants per-post maps rather than one fixed location — a real estate site plotting individual listings, for instance. WP Go Maps (formerly WP Google Maps) handles multiple markers on a single map well in its free tier; MapPress (rebranded from MapPress Easy Google Maps, and now also supporting OpenStreetMap and Leaflet alongside Google Maps) is built specifically for attaching a different map to each individual post, which the plain embed can’t do without duplicating the HTML block everywhere. Both still benefit from the same lazy-loading and consent-gating logic above — a plugin doesn’t make the underlying iframe any lighter or any more exempt from consent rules, it just gives you more UI for managing it.
For a single-location business, though, the two-minute embed — lazy-loaded, and consent-gated if the audience is in the EU — is the whole job. Nothing further to install, nothing further to maintain.
Etienne Basson works with website systems, SEO-driven site architecture, and technical implementation. He writes practical guides on building, structuring, and optimizing websites for long-term growth.