Consume WFS in Python: production guide for querying web feature services

What WFS provides—and what it does not

The OGC Web Feature Service standard defines an interface for discovering and retrieving geographic feature data. GetCapabilities returns service metadata, including available operations, feature types, and filtering capabilities. DescribeFeatureType exposes the schema for a feature type. GetFeature returns feature instances that match the request, potentially using attribute predicates, spatial constraints, identifiers, sorting, pagination, and a requested output format. The standard also defines transactional and locking operations, but a read-only consumer should not assume that an endpoint permits edits. (docs.ogc.org)

WFS is not the same as WMS. WMS returns rendered map images; WFS returns data that a client can parse and compute over. It is also not guaranteed to be a REST-style JSON API. GML is central to the WFS standard, while GeoJSON, CSV, or other formats may be optional server extensions. Check the capabilities document and the service's advertised formats instead of hard-coding application/json. (docs.ogc.org)

• •A WFS endpoint URL, including any required authentication or API key.
• •Permission to use the data, including attribution and redistribution requirements.
• •Python 3, a virtual environment, and network access to the service.
• •A working understanding of bounding boxes, coordinate reference systems, GeoJSON, XML, and basic HTTP.
• •A decision about whether the result will be analyzed in memory, written to files, or loaded into a spatial database.

Step 1: create an environment and inspect capabilities

Install the client libraries in an isolated environment. Pin versions in an application or pipeline rather than relying on whatever happens to be installed on a workstation.

• •Create and activate an environment:
• •python -m venv .venv source .venv/bin/activate # Windows: .venv\Scripts\activate
• •Install the core packages:
• •python -m pip install --upgrade pip python -m pip install OWSLib requests geopandas pyogrio

Step 2: discover versions, feature types, CRS, and formats

Begin with GetCapabilities. OWSLib parses the service metadata and exposes the advertised contents. The exact object structure can differ by WFS version, so inspect the returned keys and values rather than assuming a particular namespace or layer name.

• •Use OWSLib to inspect the service:
• •from owslib.wfs import WebFeatureService endpoint = "https://example.gov/geoserver/wfs" wfs = WebFeatureService(endpoint, version="2.0.0") print("WFS version:", wfs.version) print("Feature types:") for name, item in wfs.contents.items(): print(name, item.title, item.crsOptions, item.boundingBoxWGS84) print("Operations:") for operation in wfs.operations: print(operation.name, operation.methods, operation.formatOptions)
• •If the requested version fails, retry with a version the server documents, commonly 1.1.0 or 1.0.0. Do not infer that a server supports WFS 2.0.x merely because it uses the WFS protocol.
• •Record the feature type name exactly as advertised. Names are often namespace-qualified, for example `transport:roads` or `planning:parcels`.
• •Inspect the service's advertised CRS options and output formats. A feature type may support a narrower set of coordinate systems than the service as a whole.

Step 3: retrieve a small, explicit feature sample

Before building a full ingestion job, request one or a few features. An explicit HTTP request makes the parameters visible and is useful for diagnosing server behavior. The standard uses parameters such as SERVICE, VERSION, REQUEST, TYPENAMES or TYPENAME depending on version, OUTPUTFORMAT, COUNT or MAXFEATURES, and SRSNAME. Servers may also accept vendor-specific parameters.

• •A bounded WFS 2.0-style request with requests:
• •import requests params = { "service": "WFS", "version": "2.0.0", "request": "GetFeature", "typenames": "transport:roads", "outputFormat": "application/json", "count": 5, "srsName": "EPSG:4326", } response = requests.get(endpoint, params=params, timeout=60) response.raise_for_status() print(response.url) print(response.headers.get("content-type")) print(response.text[:500])
• •For WFS 1.0.0 or 1.1.0, the parameter may be `typename`, and the row limit may be expressed as `maxFeatures`. Confirm the spelling and behavior from the service documentation or a successful capabilities exchange.
• •If the response is XML or GML rather than GeoJSON, do not automatically treat that as an error. GML may be the default or only advertised feature encoding. Save the response and inspect its XML namespaces, schema location, and feature members.
• •Use `response.url` in logs. It captures the final encoded query and can be invaluable when a filter, namespace, or coordinate value is not being interpreted as expected.

Step 4: load the response into GeoPandas

When the service supports GeoJSON, load the response into a GeoDataFrame. GeoPandas can read from URLs and file-like objects, and its `bbox`, `mask`, `columns`, and `rows` parameters can reduce the amount of data read when the underlying driver and service support partial access. For a WFS workflow, explicit requests are often preferable because they let you control server-side filters and preserve the exact request metadata.

• •Load a GeoJSON response directly:
• •import io import geopandas as gpd geojson_bytes = response.content gdf = gpd.read_file(io.BytesIO(geojson_bytes)) print(gdf.head()) print(gdf.columns.tolist()) print(gdf.crs) print(gdf.geometry.geom_type.value_counts())
• •If the response is saved to disk, use a stable name that includes the source, feature type, retrieval date, and query scope. For example: `roads_transport_bbox_2026-09-09.geojson`.
• •GeoPandas documents that URL reads may be passed to the underlying GDAL engine when partial reading is supported; otherwise the URL may be downloaded into memory. For large responses, use server-side limits, bounding boxes, property selection, pagination, or a staged download instead of assuming that `read_file` will stream an unlimited layer safely. (geopandas.org)

Step 5: add filters, pagination, and CRS checks

WFS filtering is where a prototype becomes an application. Attribute filters may use a server's supported Filter Encoding capabilities or a vendor-specific query syntax. Spatial filters commonly include a bounding box, but axis order and CRS interpretation must be verified. The OGC specification defines query predicates and feature retrieval, while individual services advertise the filter capabilities they support. (docs.ogc.org)

Start with a bounding box in a CRS that the service clearly supports. Then compare the returned extent with the requested extent. If a result appears on the wrong continent, the issue is often coordinate order or an incorrectly interpreted CRS rather than missing data.

• •Example bounding-box request:
• •params = { "service": "WFS", "version": "2.0.0", "request": "GetFeature", "typenames": "transport:roads", "outputFormat": "application/json", "bbox": "-122.45,37.74,-122.38,37.81,urn:ogc:def:crs:EPSG::4326", "count": 100, }
• •For a local GeoDataFrame, make the CRS explicit before measuring or joining:
• •if gdf.crs is None: raise ValueError("The response has no CRS metadata") gdf = gdf.to_crs("EPSG:3857") lengths_m = gdf.geometry.length
• •Do not use longitude and latitude degrees as if they were meters. Reproject to an appropriate projected CRS for local distance or area calculations, or use a geodesic method where that is the intended measurement.
• •Implement pagination only after confirming the service's version and advertised parameters. WFS 2.0 commonly uses `startIndex` and `count`; older services commonly use `maxFeatures`. Enforce a maximum page size and stop when the service returns fewer features than requested or provides a total count.
• •For repeatable pipelines, store the source URL, WFS version, feature type, filter, bounding box, requested CRS, output format, retrieval timestamp, response status, and source-provided identifiers.

Step 6: validate and operate the consumer in production

A successful HTTP 200 response does not prove that the data is usable. Validate content type, feature count, geometry presence, geometry types, CRS, required fields, duplicate identifiers, and plausible geographic bounds. Keep the raw response or a content hash when the source is important enough to audit.

Use timeouts and retries for transient network failures, but do not retry an invalid request indefinitely. Back off when the service returns rate-limit or server-error responses. Respect provider terms, advertised limits, attribution requirements, and maintenance windows. A public endpoint should not be treated as an unlimited bulk-download backend.

• •Operational checks worth automating:
• •assert response.status_code == 200 assert response.content assert len(gdf) <= 100000 assert gdf.geometry.notna().all() assert gdf.total_bounds[0] >= -180 and gdf.total_bounds[2] <= 180 if gdf.crs.to_epsg() == 4326 else True
• •Run a small canary query before a full job.
• •Compare feature counts and extents with recent successful runs.
• •Alert on schema changes, missing columns, unexpected geometry types, or a sudden empty response.
• •Separate source freshness from application freshness: a newly retrieved WFS response may still represent data that the publisher updates infrequently.