What Is a Negative Buffer in GIS?

A negative buffer shrinks a polygon inward by a specified distance. If a positive 100-metre buffer expands a polygon outward, a negative 100-metre buffer moves its boundary inward and keeps only the area that remains sufficiently far from that boundary.

Negative buffers are commonly used to create inward setbacks, remove narrow edge zones, or identify the interior portion of an area. But they do not simply make a polygon proportionally smaller. The result depends on the polygon's shape: narrow sections can disappear, holes can expand, one feature can split into several pieces, and a sufficiently large negative distance can eliminate the polygon entirely.

That makes negative buffering a geometric operation rather than a generic resize command.

Negative buffers at a glance

Column 1: Direction; Positive buffer: Outward; Negative buffer: Inward
Column 1: Typical input; Positive buffer: Points, lines, or polygons; Negative buffer: Polygons
Column 1: Typical result; Positive buffer: Expanded area; Negative buffer: Reduced polygon area
Column 1: Can geometry disappear?; Positive buffer: Normally not from positive distance alone; Negative buffer: Yes
Column 1: Can narrow parts disappear?; Positive buffer: Not through contraction; Negative buffer: Yes
Column 1: Can one polygon become disconnected?; Positive buffer: Possible depending on geometry; Negative buffer: Yes
Column 1: Typical question; Positive buffer: What lies within a distance of this feature?; Negative buffer: What part remains after moving inward from the boundary?

QGIS's Buffer documentation explicitly allows negative distances for polygon inputs and describes the result as a smaller polygon or setback.

A negative buffer moves the boundary inward

Imagine a rectangular parcel that is 200 metres wide.

If you create a negative 20-metre buffer, the resulting polygon is set back 20 metres from each edge.

Conceptually:

Original
+------------------------+
|                        |
|                        |
|                        |
+------------------------+

Negative buffer
    +----------------+
    |                |
    |                |
    +----------------+

The output is not produced by changing the map scale or multiplying every coordinate by some percentage. Instead, the geometry is reconstructed according to a distance from its boundary.

This distinction becomes important as soon as the input is not a simple rectangle.

A 20-metre negative buffer means approximately the same inward distance from the polygon boundary regardless of whether a particular part of the shape is wide, narrow, straight, or curved. The shape therefore changes according to its geometry rather than according to a uniform percentage.

A negative buffer is not the same as scaling a polygon

Suppose you reduce a polygon to 80 percent of its original size using a geometric scaling transformation.

Every coordinate can move relative to a chosen origin, often the centroid or another reference point. The resulting distance between the original and new boundary will generally vary around the polygon.

A negative buffer works differently.

It asks for an inward offset based on a specified distance. With a nominal -100 m buffer, the construction is based on 100 metres from the boundary rather than “make the object 10 percent smaller”.

For irregular geometry, the difference can be substantial.

Scaling is useful when the intended transformation is proportional.

Negative buffering is useful when the intended transformation is distance-based.

Negative buffers are primarily a polygon operation

A positive buffer around a point or line creates a polygonal area surrounding that geometry.

Trying to move a point “inward” has no equivalent meaning because a point has no interior area. Likewise, a line has no polygon interior to contract.

Implementations therefore generally associate useful negative-buffer behaviour with polygonal inputs. PostGIS, for example, states that a negative distance shrinks polygon geometry and may eliminate it completely, while negative buffers of points and lines return empty results. See PostGIS — ST_Buffer.

If the goal is to offset a line to one side rather than create an inward polygon setback, an offset curve or single-sided operation expresses a different concept.

The polygon can disappear completely

Suppose a square is 100 metres wide.

An inward offset of 10 metres leaves a smaller square.

An inward offset approaching 50 metres leaves almost nothing.

Beyond the distance at which no interior can remain, the result becomes empty.

This is not necessarily an error.

The negative buffer has asked:

Which area remains after moving inward by this distance from the polygon boundary?

If no such area exists, an empty result is geometrically appropriate.

PostGIS documents this behaviour explicitly: a sufficiently large negative buffer can shrink a polygon completely and return an empty polygon.

This makes empty outputs something to interpret rather than automatically troubleshoot.

Narrow parts can disappear before the whole polygon does

Real polygons are rarely simple squares.

Consider a polygon with two large areas connected by a narrow corridor:

+---------+       +---------+
|         |-------|         |
|         |       |         |
+---------+       +---------+

Suppose the connecting corridor is only 30 metres wide.

A negative buffer of 20 metres applied from each side can eliminate that narrow connection even though large portions of both wider areas remain.

The result may become two disconnected pieces:

+-------+           +-------+
|       |           |       |
+-------+           +-------+

This is one of the most important properties of negative buffering.

The operation can change topological structure, not merely area.

A feature that began as one connected polygon may become a multipart geometry or several separate features depending on how the software represents the result.

Small protrusions can vanish

The same effect occurs with narrow peninsulas, spikes, and small appendages.

Imagine an irregular polygon with a thin projection:

+-------------+
|             |------+
|             |      |
|             |------+
+-------------+

If the projection is narrower than the amount removed from both sides, it disappears from the negative-buffered result.

This can occasionally make negative buffering look like a geometry-cleaning tool because small or narrow features are removed.

But that does not mean they were errors.

A narrow section may represent a real corridor, access strip, river branch, parcel extension, coastal feature, or ecological connection. Removing it simply because the resulting polygon looks cleaner can change the geographic meaning of the data.

Holes behave differently from the outer boundary

A polygon can contain interior rings, commonly described as holes.

For example:

+----------------------+
|                      |
|      +--------+      |
|      |  hole  |      |
|      +--------+      |
|                      |
+----------------------+

A negative buffer contracts the usable polygon area.

That means:

the outer boundary moves inward;
the boundary around an internal hole effectively moves outward into the polygon.

The remaining area becomes narrower from both directions.

With a sufficiently large negative distance, the expanding hole can meet the contracting outer boundary and cause parts of the polygon to disappear or split.

This is another reason the result cannot be understood as simply “a smaller copy of the original”.

The structure of the polygon matters.

A negative buffer can identify an interior zone

One useful way to interpret a negative buffer is as an interior setback.

Suppose a land-management workflow wants the portion of a polygon that remains after excluding a 100-metre zone along its boundary.

A -100 m buffer can produce a candidate interior region.

Conceptually:

Original polygon
+----------------------+
| boundary zone        |
|   +--------------+   |
|   |   interior   |   |
|   |              |   |
|   +--------------+   |
|                      |
+----------------------+

The negative-buffered polygon represents the interior remainder.

If the surrounding edge zone itself is needed, it can be derived separately as the difference between the original polygon and its negative buffer.

That distinction is useful:

negative buffer → interior remainder;
original minus negative buffer → internal boundary band.

The two outputs answer different questions.

A negative buffer can model a setback—but only if distance is the rule

Suppose a regulation states that development must remain at least 50 metres inside a parcel boundary.

A negative 50-metre buffer may provide a useful geometric representation of the part of the parcel remaining after that setback.

But the operation is appropriate only if the rule can genuinely be represented as a uniform geometric distance from the mapped boundary.

Real restrictions may instead depend on:

different distances along different boundary segments;
roads or waterways;
legal easements;
slope;
parcel access;
building orientation;
exceptions or grandfathered structures;
another authoritative boundary dataset.

A negative buffer does not know any of those rules.

It implements the distance model supplied to it.

Negative buffering is not erosion in the everyday sense

GIS and computational geometry sometimes describe negative buffering as erosion, because the polygon is reduced inward.

That analogy can be useful: thin pieces vanish and larger regions contract.

But it is important not to turn the metaphor into a physical interpretation.

A negative buffer applied to a wetland polygon does not model environmental erosion. A negative buffer of a forest polygon does not describe forest loss. A negative buffer around an administrative area does not mean the territory has actually contracted.

The result is derived geometry created by a mathematical rule.

Its meaning comes from the analysis, not from the word buffer or erosion itself.

The distance still depends on the CRS

A negative buffer of:

-100

has the same measurement problem as a positive buffer of:

What does 100 mean?

If the geometry operation uses the units of a projected CRS expressed in metres, it may mean 100 projected metres.

If it is operating directly on longitude and latitude coordinates without geography-aware handling, the units may instead be degrees.

And even a metre-based projection can introduce distance distortion depending on its purpose and area of use.

Why Buffer Distance Depends on the CRS explains that issue in detail.

The negative sign changes the direction of the offset. It does not solve the measurement problem.

Join style can influence the exact result

Buffer algorithms need rules for constructing new geometry around corners.

Common join styles include:

round;
mitre;
bevel.

These options also affect negative polygon buffers.

For a simple or large polygon, the differences may be minor. Around sharp corners and narrow geometry, the selected style and approximation settings can alter the exact shape of the output.

QGIS and PostGIS both expose buffer-style controls for geometry construction.

For an ordinary conceptual setback, default settings may be sufficient. For precision-sensitive work, the geometry-construction parameters should be documented rather than treated as irrelevant interface details.

Negative buffers can expose narrow geometry

Suppose a polygon survives a -5 m buffer but disappears under -10 m.

That tells you something about its geometric width.

Similarly, if one part of a feature disconnects under a moderate negative buffer, that indicates a narrow connection somewhere in the geometry.

This can make negative buffering useful in exploratory geometric analysis.

But it should not be confused with an exact measurement of minimum width unless the method has been specifically designed and validated for that purpose.

The disappearance threshold is influenced by geometry, shape, holes, corners, and the buffer implementation. It is evidence about the feature's spatial structure, not automatically a formal width statistic.

What happens to attributes?

Like a positive buffer, a negative buffer changes geometry.

Attributes that were derived from the original geometry may therefore become stale.

Suppose a polygon has:

area_ha = 75.4

After an inward buffer, its area may be substantially smaller while the stored attribute still says 75.4.

Fields representing:

area;
perimeter;
shape indices;
geometry-dependent classifications;

may need to be recalculated if they are expected to describe the new geometry.

Other attributes may still be valid. A feature identifier or land-use category can continue to describe the source from which the setback was derived.

The important question is whether the field describes the source feature or the new derived geometry.

Negative buffer is not Clip

Both operations can make polygons smaller.

But they use completely different rules.

Clip says:

Keep the part of my input that falls inside this other geometry.

Negative Buffer says:

Move my own boundary inward by this distance.

Clip requires another geographic boundary.

Negative buffer requires a distance.

Suppose a parcel needs to be restricted to the portion inside a planning zone. That is a clipping or overlay question.

Suppose instead that all locations within 20 metres of the parcel boundary should be excluded. That is an inward-buffer question.

Choosing between them depends on whether the constraint is defined by another geometry or by distance from the feature's own boundary.

Negative buffer is not Simplify

A negative buffer can remove small projections and narrow details, making the result appear visually simpler.

That does not make it a simplification operation.

Geometry simplification usually tries to reduce vertices while retaining the broad form of a line or polygon.

Negative buffering changes the actual occupied area according to distance from the boundary.

A polygon could lose half its area under a large negative buffer even if its geometry contains very few vertices.

Conversely, a highly detailed polygon might be simplified substantially while retaining approximately the same overall footprint.

The operations solve different problems.

The upcoming What Is Geometry Simplification? article owns the latter.

When should you use a negative buffer?

A negative buffer is appropriate when the intended question is genuinely an inward distance rule.

Examples include:

What portion of this polygon remains at least 50 metres inside its outer boundary?

What is the interior of this site after applying a uniform geometric setback?

Which parts of these polygons remain after removing a boundary zone of a specified width?

What happens to these polygons as their boundaries are offset inward?

It is less appropriate when the intended transformation is:

proportional resizing;
clipping to another geographic boundary;
general geometry cleaning;
smoothing a jagged outline;
simplifying a dataset for display;
modelling a physical process without a uniform distance rule.

Those operations may also produce smaller or cleaner-looking geometry, but for different reasons.

Always inspect disappearing and split features

After a substantial negative buffer, do not verify the operation only by checking that an output layer exists.

Inspect:

how many input features disappeared;
whether connected polygons became disconnected;
whether multipart geometry was created;
whether holes expanded in important ways;
whether narrow corridors vanished;
whether geometry-derived attributes are still valid;
whether the buffer distance and CRS were appropriate.

A disappearing polygon may be the correct mathematical result.

But it may also reveal that the chosen distance was too large for the intended analytical meaning.

The geometry alone cannot decide that.

A negative buffer answers an inward-distance question

The simplest definition is also the most useful:

A negative buffer keeps the portion of a polygon that remains after its boundary is offset inward by a specified distance.

From that rule follow the behaviours that can initially seem surprising.

Small polygons can disappear because no interior remains. Narrow connections can vanish because there is not enough width to survive the setback. Holes can grow relative to the remaining polygon. Connected features can split because their narrowest parts are removed first.

Those are not side effects unrelated to the operation. They are consequences of defining the result by distance from the boundary.

So before using a negative buffer, ask:

Is an inward distance actually the rule I want to model?

If the answer is yes, negative buffering is a direct and useful operation. If the goal is merely to make a polygon look smaller or cleaner, another vector operation probably expresses the task more accurately.

References

QGIS Documentation — Buffer. Documents negative buffer distances for polygon inputs and describes the resulting smaller polygon or setback, alongside the geometry-construction parameters available to the Buffer algorithm.
PostGIS — ST_Buffer. Defines negative buffering as shrinking geometry, documents that sufficiently large negative distances can eliminate polygons completely, and states that negative buffers of points and lines return empty results.