---
title: "SQL SSRS Report in ASP.NET Core: A Beginner’s Guide"  
description: "Learn how to create and integrate SQL SSRS Reports with ASP.NET Core. A beginner-friendly guide covering SSRS, RDL, datasets, parameters, Report Server, PDF"  
author: "Yogendra  Mohan"  
published: 2026-09-02  
updated: 2026-09-02  
canonical: https://answers.mindstick.com/blog/587/sql-ssrs-report-in-asp-dot-net-core-a-beginner-s-guide  
category: "SSRS"  
tags: ["ssrs", "reports", "ASP.NET Core"]  
reading_time: 18 minutes  

---

# SQL SSRS Report in ASP.NET Core: A Beginner’s Guide

## 1. What is SSRS?

### What?

**SSRS stands for SQL Server Reporting Services.**

It is a Microsoft reporting platform used to create, manage, and deliver reports using data from databases and other data sources.

For example, suppose you have an application that stores customer orders in SQL Server.

You might want a report like:

| Order ID | Customer | Order Date | Amount |
| --- | --- | --- | --- |
| 1001 | John | 01-Sep-2026 | $500 |
| 1002 | Sarah | 02-Sep-2026 | $750 |
| 1003 | David | 02-Sep-2026 | $320 |

Instead of writing all the reporting logic yourself, you can create an SSRS report that retrieves and formats this data.

### Why?

SSRS is useful when you need:

- Printable reports
- PDF reports
- Excel exports
- Parameterized reports
- Tables and charts
- Grouping and summaries
- Page headers and footers
- Scheduled reports
- Business/financial reports

### How?

SSRS generally works like this:

```plaintext
SQL Server
    ↓
SQL Query / Stored Procedure
    ↓
SSRS Report (.rdl)
    ↓
SSRS Report Server
    ↓
ASP.NET Core Application
    ↓
User
```

The important thing to understand is that **ASP.NET Core does not replace SSRS**.

ASP.NET Core is your web application, while SSRS is responsible for generating and managing the report.

## 2. What is an SSRS Report?

### What?

An SSRS report is usually represented by an `.rdl` **file**.

RDL means **Report Definition Language**.

Think of an `.rdl` file as the blueprint of your report.

It contains information such as:

- Which data source to use
- Which query to execute
- Which columns to display
- Report parameters
- Tables
- Charts
- Formatting
- Grouping
- Page layout

For example:

```plaintext
SalesReport.rdl
```

might define a report containing:

```plaintext
Customer
Order Date
Product
Quantity
Total Amount
```

### Why?

Separating the report definition from your application makes reports easier to design and maintain.

You can change the report layout without rewriting your entire ASP.NET Core application.

### How?

You typically create an RDL file using a reporting designer such as [**Microsoft Report Builder**](https://learn.microsoft.com/en-us/sql/reporting-services/install-windows/install-report-builder?view=sql-server-ver17) or [**SQL Server Data Tools (SSDT)**](https://learn.microsoft.com/en-us/sql/ssdt/sql-server-data-tools?view=sql-server-ver17).

## 3. What is Report Builder?

### What?

**Report Builder** is a Microsoft tool for designing SSRS reports.

It provides a visual interface where you can create:

- Tables
- Charts
- Text boxes
- Parameters
- Groups
- Filters
- Headers
- Footers

You don't have to manually write the RDL XML.

### Why?

As a beginner, manually creating RDL files would be unnecessarily difficult.

Report Builder lets you visually design the report.

For example:

```plaintext
+---------------------------------------+
|          SALES REPORT                 |
+---------------------------------------+
| Customer | Date       | Amount        |
+---------------------------------------+
| John     | 01-Sep     | $500          |
| Sarah    | 02-Sep     | $750          |
+---------------------------------------+
| Total                    $1,250       |
+---------------------------------------+
```

### How?

You generally:

- Install/open Report Builder.
- Create a new report.
- Create a data source.
- Create a dataset.
- Add a table or other report item.
- Select the fields you want to display.
- Add parameters if required.
- Format the report.
- Save the report as an `.rdl` file.
- Deploy/upload it to the SSRS Report Server.

## 4. What is a Report Server?

### What?

An **SSRS Report Server** is the server that hosts your SSRS reports.

For example:

```plaintext
https://your-server/ReportServer
```

The exact URL depends on how SSRS was installed and configured.

The Report Server stores and executes your reports.

### Why?

Without a report server, you don't have the normal SSRS environment for hosting and executing server-based SSRS reports.

The server can manage:

- Reports
- Data sources
- Report parameters
- Security
- Report execution
- Subscriptions
- Report history
- Caching

### How?

A typical setup looks like:

```plaintext
                SQL Server
                    ↑
                    |
              SSRS Report Server
                    ↑
                    |
             ASP.NET Core App
                    ↑
                    |
                  User
```

## 5. What is a Data Source?

### What?

A **data source** tells SSRS where the report's data comes from.

For example, your data source could point to SQL Server.

Conceptually:

```plaintext
Server: MySqlServer
Database: SalesDB
Authentication: SQL/Windows
```

### Why?

SSRS needs to know where it should retrieve the data.

Without a data source, your report doesn't know where the customer/order information is located.

### How?

In Report Builder, you can create a data source and configure the SQL Server connection.

For example:

```plaintext
Data Source Name:
SalesDatabase

Database:
SalesDB
```

## 6. What is a Dataset?

This is one of the most important concepts for SSRS beginners.

### What?

- A **dataset** defines the data that your report uses.
- A data source tells SSRS **where the database is**.
- A dataset tells SSRS **what data to retrieve**.

Think of it this way:

```plaintext
Data Source
     ↓
Where is the database?

Dataset
     ↓
What data do I want?
```

### Why?

Your report needs a specific set of records to display.

For example, you might create a dataset using:

```plaintext
SELECT
    OrderId,
    CustomerName,
    OrderDate,
    TotalAmount
FROM Orders;
```

### How?

In Report Builder:

```plaintext
Report
  ↓
Dataset
  ↓
SQL Query
  ↓
SQL Server
  ↓
Records
```

The resulting fields might be:

```plaintext
OrderId
CustomerName
OrderDate
TotalAmount
```

You can then drag those fields into your report table.

## 7. What is a Stored Procedure in SSRS?

### What?

Instead of writing a SQL query directly in the SSRS dataset, you can use a **stored procedure**.

For example:

```plaintext
CREATE PROCEDURE GetSalesReport
    @StartDate DATE,
    @EndDate DATE
AS
BEGIN

    SELECT
        OrderId,
        CustomerName,
        OrderDate,
        TotalAmount
    FROM Orders
    WHERE OrderDate BETWEEN @StartDate AND @EndDate;

END
```

SSRS can execute this stored procedure and use the returned data in the report.

### Why?

## Stored procedures are useful when:

- The query is complex
- You want centralized SQL logic
- You need parameters
- Multiple applications use the same reporting logic
- You want database-side control over the query

### How?

Your SSRS dataset can be configured to execute:

```plaintext
GetSalesReport
```

with parameters such as:

```plaintext
@StartDate
@EndDate
```

## 8. What are SSRS Parameters?

### What?

Parameters allow users to provide values to a report.

For example:

```plaintext
Start Date: 01-Sep-2026
End Date:   30-Sep-2026
```

The report can then display only the records for that date range.

### Why?

Without parameters, your report might always show every record in the database.

Parameters make reports dynamic.

For example:

```plaintext
Customer Report

Customer:
[ John ▼ ]

Start Date:
[ 01-Sep-2026 ]

End Date:
[ 30-Sep-2026 ]

        [ View Report ]
```

### How?

Suppose your SQL query is:

```plaintext
SELECT *
FROM Orders
WHERE OrderDate BETWEEN @StartDate AND @EndDate;
```

You create two SSRS report parameters:

```plaintext
StartDate
EndDate
```

SSRS passes those values to the dataset query.

## 9. What is the relationship between ASP.NET Core and SSRS?

This is where beginners often get confused.

### What?

- ASP.NET Core and SSRS are two different technologies.
- **ASP.NET Core** is used to build your web application.
- **SSRS** is used to generate and manage reports.
- They can work together.

### Why?

Suppose your ASP.NET Core application has this page:

```plaintext
Sales Dashboard

Start Date: [01-Sep-2026]
End Date:   [30-Sep-2026]

[ Generate Report ]
```

When the user clicks **Generate Report**, your application can request the SSRS report.

Conceptually:

```plaintext
Browser
   ↓
ASP.NET Core
   ↓
SSRS
   ↓
SQL Server
   ↓
SSRS generates report
   ↓
ASP.NET Core / Browser
```

## 10. Can ASP.NET Core directly run an RDL file?

### What?

An `.rdl` file is a report definition. Simply putting an RDL file inside your ASP.NET Core project does not automatically make ASP.NET Core understand and render it.

### Why?

RDL is designed for the SSRS reporting environment.

The report normally needs a reporting engine/server capable of processing it.

### How?

A common architecture is:

```plaintext
ASP.NET Core
       |
       | Request report
       ↓
SSRS Report Server
       |
       | Execute report
       ↓
SQL Server
```

ASP.NET Core can then provide the report to the browser or use the generated report output as appropriate.

## 11. How do I create an SSRS report?

Let's look at the complete beginner workflow.

### Step 1: Create your SQL table

For example:

```plaintext
CREATE TABLE Employees
(
    Id INT,
    Name VARCHAR(100),
    Department VARCHAR(100),
    Salary DECIMAL(18,2)
);
```

Insert some data:

```plaintext
INSERT INTO Employees
VALUES
(1, 'John', 'IT', 50000),
(2, 'Sarah', 'HR', 45000),
(3, 'David', 'Finance', 60000);
```

### Step 2: Create a report

Open Report Builder and create a new report.

Give it a name such as:

```plaintext
EmployeeReport.rdl
```

### Step 3: Create a data source

Configure your SQL Server connection.

For example:

```plaintext
Server: MyServer
Database: CompanyDB
```

### Step 4: Create a dataset

Use:

```plaintext
SELECT
    Id,
    Name,
    Department,
    Salary
FROM Employees;
```

### Step 5: Add a table

Add a table to the report.

Your table could look like:

```plaintext
+----+--------+------------+--------+
| ID | Name   | Department | Salary |
+----+--------+------------+--------+
| 1  | John   | IT         | 50000  |
| 2  | Sarah  | HR         | 45000  |
| 3  | David  | Finance    | 60000  |
+----+--------+------------+--------+
```

### Step 6: Preview

Click **Preview**.

SSRS executes your dataset query and displays the report.

### Step 7: Deploy the report

Upload/deploy the `.rdl` file to your SSRS Report Server.

Now your report is available on the server.

## 12. How does ASP.NET Core call the SSRS report?

There are several approaches, depending on your SSRS setup and the experience you want to provide.

A common approach is to use the SSRS report server's URL and pass report parameters.

Conceptually:

```plaintext
https://server/ReportServer?
/Reports/EmployeeReport
&rs:Format=PDF
```

Parameters can also be supplied.

For example:

```plaintext
StartDate=2026-09-01
EndDate=2026-09-30
```

The exact URL and authentication approach depends on your SSRS configuration.

### Important

Don't assume that every SSRS installation uses the same URL, authentication mechanism, or embedding configuration. These are environment-specific.

## 13. What does `rs:Format=PDF` mean?

### What?

SSRS supports different output formats.

For example:

```plaintext
PDF
Excel
Word
CSV
HTML
```

A report request can specify an output format.

Conceptually:

```plaintext
&rs:Format=PDF
```

means:

```plaintext
Generate the report as PDF.
```

### Why?

Suppose your ASP.NET Core application has a button:

```plaintext
[ Download PDF ]
```

Your application can request the report in PDF format.

## 14. How can I display the SSRS report in ASP.NET Core?

There are different ways to integrate reports.

## Option 1: Open the SSRS report

Your ASP.NET Core application can provide a link/button that opens the report on the SSRS server.

For example:

```plaintext
[ View Sales Report ]
```

The user is redirected to the report.

### Advantage

Simple to implement.

### Disadvantage

The user may leave your application's UI.

## 15. What about embedding the report?

### What?

You can integrate the report experience into your application's interface, depending on your SSRS configuration and authentication setup.

Conceptually:

```plaintext
+----------------------------------------+
|       My ASP.NET Core Application      |
|                                        |
| Start Date: [01-Sep]                   |
| End Date:   [30-Sep]                   |
|                                        |
| +------------------------------------+ |
| |            SSRS Report             | |
| |                                    | |
| | Customer | Date | Amount           | |
| | John     | ...  | $500             | |
| +------------------------------------+ |
+----------------------------------------+
```

### Why?

This gives users a more seamless experience.

They don't necessarily need to navigate to a separate reporting application.

### How?

The implementation depends on your SSRS version, authentication configuration, deployment model, and whether you're using a server-hosted report viewer or generating report output through the server.

For ASP.NET Core, avoid assuming that older ASP.NET Framework ReportViewer examples will work unchanged. Many older tutorials were written for the classic .NET Framework ecosystem.

## 16. What is ReportViewer?

### What?

**ReportViewer** is a Microsoft reporting component historically used to display SSRS or local reports in .NET applications.

You may find many tutorials showing code such as:

```plaintext
ReportViewer reportViewer = new ReportViewer();
```

### Why is this confusing?

A large amount of SSRS documentation and sample code on the internet targets:

```plaintext
ASP.NET MVC
ASP.NET Web Forms
.NET Framework
```

rather than modern:

```plaintext
ASP.NET Core
.NET 6+
.NET 8+
.NET 9+
```

Therefore, you should check whether a particular ReportViewer library actually supports your target ASP.NET Core/.NET version before adopting it.

### Beginner advice

Don't start by searching for:

> "How to put ReportViewer in ASP.NET Core"

and blindly copying an old tutorial.

First understand the architecture:

```plaintext
ASP.NET Core
      ↓
SSRS Report Server
      ↓
SQL Server
```

Then choose the integration method that matches your environment.

## 17. How do report parameters flow from ASP.NET Core to SSRS?

Suppose your report has:

```plaintext
CustomerId
```

The user selects:

```plaintext
CustomerId = 10
```

The flow is:

```plaintext
User
 ↓
ASP.NET Core
 ↓
CustomerId = 10
 ↓
SSRS
 ↓
Dataset
 ↓
SQL Server
```

Your dataset might contain:

```plaintext
SELECT *
FROM Orders
WHERE CustomerId = @CustomerId;
```

SSRS receives:

```plaintext
CustomerId = 10
```

and executes the query.

## 18. What is the difference between an SSRS Parameter and a SQL Parameter?

This distinction is important.

### SSRS Report Parameter

This is a parameter defined at the report level.

Example:

```plaintext
StartDate
EndDate
```

### SQL Query Parameter

This is a parameter used by the SQL query.

Example:

```plaintext
WHERE OrderDate BETWEEN @StartDate AND @EndDate
```

SSRS connects the two.

Conceptually:

```plaintext
Report Parameter
       ↓
Dataset Parameter
       ↓
SQL Parameter
       ↓
SQL Server
```

## 19. How do I add a PDF download button?

Imagine your ASP.NET Core page has:

```plaintext
[ Generate Report ]

[ Download PDF ]
```

The basic concept is:

```plaintext
Browser
   ↓
ASP.NET Core Controller
   ↓
Request SSRS report as PDF
   ↓
SSRS
   ↓
PDF bytes
   ↓
ASP.NET Core
   ↓
Browser downloads PDF
```

Your ASP.NET Core controller can return the generated file to the browser.

Conceptually, the result is:

```plaintext
return File(pdfBytes, "application/pdf", "SalesReport.pdf");
```

The exact implementation for obtaining `pdfBytes` depends on how your SSRS server is configured and how you authenticate to it.

## 20. Can SSRS export to Excel?

### What?

Yes. SSRS reports can support several export formats, depending on the report/server configuration.

Common formats include:

```plaintext
PDF
Excel
Word
CSV
XML
HTML
```

### Why?

Different users need different formats.

For example:

```plaintext
Manager → PDF
Accountant → Excel
Developer → CSV
```

### How?

Your application can request the appropriate report format from SSRS.

## 21. What is Report Parameter vs Filter?

Beginners often confuse these two.

### Parameter

A parameter receives a value from the user or application.

Example:

```plaintext
Department = IT
```

The dataset can then retrieve only IT employees.

### Filter

A filter can restrict data after the dataset has been retrieved.

For example:

```plaintext
Dataset:
1000 employees

Report Filter:
Department = IT

Displayed:
150 employees
```

### Which should you use?

For large datasets, filtering in the SQL query is often preferable because it can reduce the amount of data retrieved from the database.

For example:

```plaintext
SELECT *
FROM Employees
WHERE Department = @Department;
```

is generally more efficient than retrieving every employee and filtering them only at the report level.

## 22. What are Groups in SSRS?

### What?

Groups allow you to organize report data.

Suppose you have:

```plaintext
IT
  John
  David

HR
  Sarah
  Mike

Finance
  Robert
```

You can create a Department group.

### Why?

Groups are useful for:

- Department-wise reports
- Customer-wise reports
- Region-wise reports
- Monthly reports
- Category-wise reports

### How?

You create a group based on a field.

For example:

```plaintext
Group by:
Department
```

SSRS then organizes records according to the department.

## 23. What are SSRS Expressions?

### What?

Expressions allow you to calculate or dynamically display values in an SSRS report.

For example:

```plaintext
=Sum(Fields!Salary.Value)
```

calculates the total salary.

Another example:

```plaintext
=Count(Fields!Id.Value)
```

counts records.

### Why?

Expressions are useful for:

- Totals
- Counts
- Conditional formatting
- Dynamic text
- Date formatting
- Calculations

For example:

```plaintext
Total Salary: $155,000
```

can be calculated dynamically.

## 24. What are Subreports?

### What?

A subreport is a report embedded inside another report.

For example:

```plaintext
Customer Report
│
├── Customer: John
│
└── Order Details
      ├── Order 1001
      ├── Order 1002
      └── Order 1003
```

### Why?

- Subreports are useful when you need separate report sections or reusable report components.
- However, they can increase complexity and sometimes affect performance.
- As a beginner, start with normal datasets and grouping before introducing subreports.

## 25. What is a Shared Data Source?

### What?

A shared data source is a reusable database connection that multiple reports can use.

For example:

```plaintext
SalesReport
InventoryReport
CustomerReport
EmployeeReport
```

could all use:

```plaintext
CompanyDatabase
```

### Why?

Instead of configuring the database connection separately for every report, you can reuse the same data source.

This makes administration easier.

## 26. What is a Shared Dataset?

### What?

A shared dataset is a reusable dataset that can be used by multiple reports.

### Why?

Suppose many reports need the same list:

```plaintext
Department
```

Instead of creating the same query repeatedly, you can create a shared dataset.

## 27. How does the complete architecture work?

Let's put everything together.

Imagine an employee salary report.

### User

The user selects:

```plaintext
Department: IT
```

### ASP.NET Core

Your application receives:

```plaintext
Department = IT
```

### SSRS

The report receives:

```plaintext
Department = IT
```

### Dataset

The dataset executes:

```plaintext
SELECT
    Name,
    Department,
    Salary
FROM Employees
WHERE Department = @Department;
```

### SQL Server

SQL Server returns:

```plaintext
John    IT    50000
David   IT    60000
```

### SSRS

SSRS formats the results:

```plaintext
Employee Salary Report

Department: IT

+--------+--------+
| Name   | Salary |
+--------+--------+
| John   | 50000  |
| David  | 60000  |
+--------+--------+

Total: 110000
```

### ASP.NET Core

Your application displays or downloads the generated report.

The complete flow is:

```plaintext
             User
               |
               ↓
       ASP.NET Core App
               |
               ↓
        SSRS Report Server
               |
               ↓
          Dataset
               |
               ↓
          SQL Server
               |
               ↓
        Report Results
               |
               ↓
       ASP.NET Core / User
```

## 28. Common mistakes beginners make

## Mistake 1: Thinking SSRS is part of ASP.NET Core

It isn't.

They are separate technologies that can work together.

## Mistake 2: Thinking an RDL file can simply be displayed by a browser

An RDL file is a report definition, not the final HTML/PDF report.

It needs a reporting engine/server to process it.

## Mistake 3: Copying old ReportViewer tutorials

Many tutorials target older .NET Framework applications.

Always check whether the library and approach support your ASP.NET Core and .NET version.

## Mistake 4: Putting too much logic into the report

If your SQL query is extremely complicated, consider whether the data preparation belongs in SQL/stored procedures or another application/data layer rather than becoming a giant collection of SSRS expressions.

## Mistake 5: Retrieving huge datasets

Don't retrieve millions of rows and expect SSRS to filter everything efficiently.

Whenever possible, filter data at the database level.

For example:

```plaintext
WHERE OrderDate BETWEEN @StartDate AND @EndDate
```

is generally preferable to retrieving the entire Orders table.

## 29. Recommended learning path for an SSRS beginner

If you are completely new to SSRS, don't start with ASP.NET Core integration.

Learn SSRS first.

Follow this order:

```plaintext
1. SQL basics
      ↓
2. SSRS basics
      ↓
3. Data Sources
      ↓
4. Datasets
      ↓
5. Tables
      ↓
6. Parameters
      ↓
7. Expressions
      ↓
8. Groups
      ↓
9. Charts
      ↓
10. Exporting
      ↓
11. Report Server
      ↓
12. ASP.NET Core integration
```

This makes the learning process much easier.

## 30. Final understanding

If you remember only one thing from this article, remember this:

> **SQL Server stores the data, SSRS generates the report, and ASP.NET Core provides the application experience around that report.**

Think of the responsibilities like this:

| Technology | Main Responsibility |
| --- | --- |
| SQL Server | Stores and retrieves data |
| SQL Query/Stored Procedure | Defines what data to retrieve |
| SSRS | Designs and generates reports |
| RDL | Defines the report structure |
| Report Server | Hosts and executes reports |
| ASP.NET Core | Provides the web application/UI |
| Browser | Displays or downloads the result |

The overall process is:

```plaintext
                 SQL Server
                     ↑
                     |
              Query / Procedure
                     ↑
                     |
                SSRS Dataset
                     ↑
                     |
                 SSRS Report
                   (.rdl)
                     ↑
                     |
              SSRS Report Server
                     ↑
                     |
              ASP.NET Core
                     ↑
                     |
                  Browser
```

Once you understand this architecture, SSRS becomes much less intimidating.

The best way to learn it is to first create a simple **Employee Report**, then add a **Department parameter**, then add **grouping and totals**, and finally connect that report to an **ASP.NET Core application**.

---

Original Source: https://answers.mindstick.com/blog/587/sql-ssrs-report-in-asp-dot-net-core-a-beginner-s-guide

Copyright © MindStick Software Pvt. Ltd. This Markdown version is provided for developers, AI systems, and offline reading.