Work with SVG Filters in Python

Quick Answer: To work with SVG filters in Python, load the SVG with SVGDocument, find the target element with query_selector(), set its filter attribute with set_attribute(), and save the SVG.

from aspose.svg import SVGDocument

with SVGDocument("document.svg") as document:
    element = document.root_element.query_selector("circle")
    if element is not None:
        element.set_attribute("filter", "url(#filter-id)")
    document.save("filtered.svg")

SVG filters create visual effects such as blur, shadow, glow, lighting, and color processing. A filter is usually defined inside <defs> and applied to a visible element through a filter="url(#filter-id)" attribute. In Aspose.SVG for Python via .NET, you work with filters through the SVG DOM: find target elements, create filter primitives, set attributes, append nodes, and save the edited file.

In this article, you will learn how to:

• create an SVG blur filter in Python and apply it to an element;
• build a drop shadow filter with filter primitives;
• edit filter attributes such as stdDeviation, dx, dy, and flood-color;
• remove a filter reference from an SVG element without deleting the reusable definition.

SVG Filter Editing Basics

A filter workflow has two parts: the filter definition and the filter reference. The definition lives in <defs>, while the visible element points to it by ID.

Task	SVG markup to edit	Typical API pattern
Apply an existing filter	filter="url(#filter-id)"	Find the visible element with query_selector() and set the filter attribute
Create a new filter	<defs><filter id="..."></filter></defs>	Create SVG elements with create_element_ns() and append them with append_child()
Configure blur or shadow	Filter primitive attributes such as stdDeviation, dx, dy, flood-color	Find the primitive and update attributes
Remove an effect	filter attribute on the visible element	Remove the filter reference with remove_attribute()

How to Apply SVG Filters in Python

Use this workflow when an SVG file needs a blur, shadow, glow, or another filter effect:

1. Load the SVG file with SVGDocument.
2. Find or create the <defs> element that stores reusable definitions.
3. Find or create a <filter> element with a stable id.
4. Add or update filter primitives such as <feGaussianBlur>, <feOffset>, or <feDropShadow>.
5. Apply the filter to a visible SVG element with filter="url(#filter-id)".
6. Save the edited SVG and check the rendered output.

The examples below use svg-filters.svg as the input file.

Create and Apply a Blur Filter

A filter must be defined before a visible element can use it. The following example creates a #blur filter in <defs>, adds an <feGaussianBlur> primitive, applies the filter to the circle, and saves the result as svg-blur-filter-applied.svg.

import os
from aspose.svg import SVGDocument

SVG_NS = "http://www.w3.org/2000/svg"

input_folder = "data/"
output_folder = "output/"
input_path = os.path.join(input_folder, "svg-filters.svg")
output_path = os.path.join(output_folder, "svg-blur-filter-applied.svg")
os.makedirs(output_folder, exist_ok=True)

with SVGDocument(input_path) as document:
    svg = document.root_element
    defs = svg.query_selector("defs")

    if defs is None:
        defs = document.create_element_ns(SVG_NS, "defs")
        svg.insert_before(defs, svg.first_child)

    blur_filter = document.create_element_ns(SVG_NS, "filter")
    blur_filter.set_attribute("id", "blur")
    blur_filter.set_attribute("x", "-20%")
    blur_filter.set_attribute("y", "-20%")
    blur_filter.set_attribute("width", "140%")
    blur_filter.set_attribute("height", "140%")

    gaussian_blur = document.create_element_ns(SVG_NS, "feGaussianBlur")
    gaussian_blur.set_attribute("in", "SourceGraphic")
    gaussian_blur.set_attribute("stdDeviation", "3")

    blur_filter.append_child(gaussian_blur)
    defs.append_child(blur_filter)

    circle = svg.query_selector("circle")
    if circle is not None:
        circle.set_attribute("filter", "url(#blur)")

    document.save(output_path)

The code shows both required parts of an SVG filter workflow. The <filter> and <feGaussianBlur> elements define the effect, and the filter="url(#blur)" attribute applies that effect to the visible circle. The illustration compares the source SVG in image (a) with the blurred circle in image (b).

Create a Drop Shadow Filter

Create a new filter when the SVG does not already contain the effect you need. The next example creates a #label-shadow filter with <feDropShadow>, appends it to <defs>, and applies it to the text label.

import os
from aspose.svg import SVGDocument

SVG_NS = "http://www.w3.org/2000/svg"

input_folder = "data/"
output_folder = "output/"
input_path = os.path.join(input_folder, "svg-filters.svg")
output_path = os.path.join(output_folder, "svg-drop-shadow-filter.svg")
os.makedirs(output_folder, exist_ok=True)

with SVGDocument(input_path) as document:
    svg = document.root_element
    defs = svg.query_selector("defs")

    if defs is None:
        defs = document.create_element_ns(SVG_NS, "defs")
        svg.insert_before(defs, svg.first_child)

    shadow_filter = document.create_element_ns(SVG_NS, "filter")
    shadow_filter.set_attribute("id", "label-shadow")
    shadow_filter.set_attribute("x", "-20%")
    shadow_filter.set_attribute("y", "-20%")
    shadow_filter.set_attribute("width", "150%")
    shadow_filter.set_attribute("height", "150%")

    drop_shadow = document.create_element_ns(SVG_NS, "feDropShadow")
    drop_shadow.set_attribute("dx", "6")
    drop_shadow.set_attribute("dy", "8")
    drop_shadow.set_attribute("stdDeviation", "2")
    drop_shadow.set_attribute("flood-color", "#455a64")
    drop_shadow.set_attribute("flood-opacity", "0.6")

    shadow_filter.append_child(drop_shadow)
    defs.append_child(shadow_filter)

    label = svg.query_selector("#label")
    if label is not None:
        label.set_attribute("filter", "url(#label-shadow)")

    document.save(output_path)

This example shows both parts of the filter workflow: the reusable filter is created in <defs>, and the visible text element receives filter="url(#label-shadow)". If either part is missing, the shadow will not appear. The illustration shows the original label in image (a) and the same label with a drop shadow in image (b).

Edit Existing Filter Attributes

Filter effects are controlled by attributes on filter primitives. The following example opens the SVG created by the blur example, finds <feGaussianBlur> inside #blur, and increases its stdDeviation value.

import os
from aspose.svg import SVGDocument

input_folder = "output/"
output_folder = "output/"
input_path = os.path.join(input_folder, "svg-blur-filter-applied.svg")
output_path = os.path.join(output_folder, "svg-filter-attributes-edited.svg")
os.makedirs(output_folder, exist_ok=True)

with SVGDocument(input_path) as document:
    svg = document.root_element
    blur = svg.query_selector("#blur feGaussianBlur")

    if blur is not None:
        blur.set_attribute("stdDeviation", "8")

    document.save(output_path)

The output uses the same filter ID, but the blur is stronger because the stdDeviation value changed from 3 to 8. The illustration compares the first blur result in image (a) with the stronger blur after editing the filter primitive in image (b).

Remove a Filter from an SVG Element

Removing a filter from a visible element is different from deleting the filter definition. The next example opens the SVG created by the blur example and removes only the filter reference from the circle; the #blur definition can stay in <defs> for reuse.

import os
from aspose.svg import SVGDocument

input_folder = "output/"
output_folder = "output/"
input_path = os.path.join(input_folder, "svg-blur-filter-applied.svg")
output_path = os.path.join(output_folder, "svg-filter-removed.svg")
os.makedirs(output_folder, exist_ok=True)

with SVGDocument(input_path) as document:
    circle = document.root_element.query_selector("circle")

    if circle is not None and circle.has_attribute("filter"):
        circle.remove_attribute("filter")

    document.save(output_path)

Use this pattern when a filter should no longer affect a specific element, but other elements may still use the same filter definition.

Common Mistakes and Fixes

Problem	Fix
Filter does not appear	Make sure the visible element has filter="url(#filter-id)" and that the ID exists in <defs>
Shadow or blur is clipped	Increase the filter region with x, y, width, and height on <filter>
Filter affects the wrong element	Apply the filter attribute to the visible shape or group that should receive the effect
Editing fill or stroke does not change the effect	Update the filter primitive attributes, such as stdDeviation, flood-color, dx, or dy
Duplicate filter IDs cause confusing output	Use stable unique IDs and update url(#...) references to match
Output file is unchanged	Save the edited document and open the output path, not the input SVG

FAQ

How do I apply an SVG filter in Python?

Load the SVG with SVGDocument, find the visible target element, and set filter="url(#filter-id)" with set_attribute(). The referenced <filter> must exist in the SVG document, usually inside <defs>.

How do I create an SVG blur filter?

Create a <filter> element in <defs>, add an <feGaussianBlur> primitive, set stdDeviation, then apply the filter to a visible element with filter="url(#filter-id)".

How do I add a drop shadow to SVG in Python?

Create a filter with a shadow primitive such as <feDropShadow>, set attributes like dx, dy, stdDeviation, and flood-color, append the filter to <defs>, and apply it with filter="url(#filter-id)".

Can I edit existing SVG filter attributes?

Yes. Find the filter primitive, such as #blur feGaussianBlur, and update attributes like stdDeviation. Save the SVG after the change.

Can I remove a filter without deleting it from defs?

Yes. Remove the filter attribute from the visible element. The <filter> definition may remain in <defs> if other elements still use it or if you want to reuse it later.

Related Articles

• Advanced SVG Editing in Python collects focused workflows for editing SVG styles, geometry, filters, and reusable artwork.
• Edit SVG Styles in Python covers presentation attributes, inline styles, CSS blocks, and style priority.
• Change SVG Colors in Python explains color edits for fills, strokes, inline styles, and gradients.
• Edit SVG Elements with CSS Selectors in Python shows how to target SVG elements before applying filters or other edits.
• Work with SVG Attributes explains how to get, set, check, and remove SVG attributes.