What Actually Happens When You Push WordPress Content From One Site to Another
In short: pushing a post from one WordPress site to another isn't a file copy, a database export, or an XML import — it's a single signed request carrying one self-contained package for that one post. The destination site checks the package hasn't been altered, imports its media before it touches anything else, writes the post, then applies its meta and taxonomies. Push the same post again later and it updates the post it already created instead of making a second one.
It's a signed request, not a file copy
There's no SFTP, no database dump, and no WordPress export/import XML file involved. When you push a post, the sending site builds one JSON package for it and POSTs it straight to the destination's own REST API, at a route like postdeploy/v1/import. The request carries an HMAC signature the destination verifies before it even looks at the payload — so a request that didn't genuinely come from a site you connected gets rejected before any content is read, let alone written.
What's actually inside the package
One package describes one object, nothing more:
- object — the post's own fields: title, content, status, slug, dates, and so on.
- meta — its custom field values.
- taxonomies — the categories, tags, and other terms attached to it.
- media — references to its featured image and any images actually used in its content, each tagged with the role it plays.
- checksum — a SHA-256 hash of everything above it.
The destination recomputes that checksum itself and refuses the package outright if it doesn't match what was sent — not a transport-security check (TLS already covers that), but a guard against the package's content changing after it was built, whether from a bug or from tampering somewhere in between.
Media imports before the post is even written
The destination doesn't create the post first and backfill images after. It imports every referenced image first, and only writes the post once that's done. That ordering is deliberate: media is the step most likely to fail — a source file that's gone missing, a destination upload directory that's not writable — and running it first means a failure there leaves nothing behind at all, not a post with broken images in it.
Once media is in, the post's content gets two separate passes of rewriting: a visible <img src="..."> URL gets swapped to point at the newly imported copy, and separately, a Gutenberg block's own internal reference — the attachment ID a block like Image or Gallery stores as a bare number inside its block comment, not as a URL — gets resolved to the new attachment's ID. The second pass exists because a simple URL find-and-replace can't see inside a block's own JSON; it needs the source-to-destination attachment ID pairing media import just produced.
Push the same thing twice and it updates, not duplicates
Before the destination ever creates a new post, it checks whether this exact source object has been pushed here before. The first successful push records that pairing — this source post, on this connection, became that destination post. Every later push of the same post looks that pairing up first: if it finds one, it updates the existing post instead of inserting a new one. There's no special "sync" step to remember to run — pushing is already idempotent, so re-pushing a page you've already pushed, after editing it further, just lands the latest version on top of what's already there.
What happens when something fails partway
Whether a failure is destructive depends entirely on whether the destination post already existed. If this is the very first push of a post and something fails after the post was created but before meta, taxonomies, and verification all finished, PostDeploy deletes that half-written post and any media attachment it had just uploaded for it — a half-built post is worse than no post, so nothing broken is left for someone to find later. If the destination post already existed from an earlier successful push, that safety net doesn't apply in reverse: a failed re-push never deletes or reverts a post that was already there. It just leaves that post exactly as it was before you tried.
Push and pull are the same pipeline, just started from different sides
PostDeploy supports pushing from the source site's own admin (what this post describes) and pulling from the destination site's admin instead, browsing a connected site's content and bringing a post over. Both end up running through the exact same import pipeline — same package format, same checksum check, same media-first ordering, same idempotent mapping. The only difference is which site's wp-admin you're sitting in when you start it, and therefore which site makes the outbound request to the other.
Frequently asked questions
If I push the same post twice, do I end up with two copies on the destination site?
No. The first push records a mapping between the source post and the destination post it created. Every later push of that same post looks up that mapping first and updates the existing destination post instead of inserting a new one — so pushing the same page five times still leaves exactly one post on the other end.
Does pushing a post copy my whole database or site over?
No. A push sends one signed package for the specific post or page you chose — its fields, meta, taxonomies, and the media it actually references — over a single authenticated HTTPS request to the destination's REST API. Nothing else on either site is read, copied, or touched.
What happens to the destination site if a push fails partway through?
It depends on whether the post already existed there. If this was the first push and it fails after the post was created but before everything else finished, PostDeploy deletes that half-written post and any media it had just uploaded, so nothing broken is left behind. If the post already existed from an earlier successful push, a failed re-push never deletes or reverts it — only a successful run updates it.
Try it
PostDeploy Free pushes Posts, Pages, and custom post types between any two WordPress sites this way — one signed package per post, idempotent by default. PostDeploy Pro adds ACF, Elementor, and WPML reference resolution to that same pipeline, plus conflict detection and rollback for when a destination post has changed since your last push. See content deployment for the broader feature overview.