> Fetch clean Markdown by appending `.md` to any page URL under https://signalwire.com/docs or requesting it with the HTTP header `Accept: text/markdown`. The root index at https://signalwire.com/docs/llms.txt lists the available documentation indexes.

# List projects

GET https://%7BYour_Space_Name%7D.signalwire.com/api/projects

Lists the projects the caller can reach.

With a project API token, that is the authenticated root project and its
subprojects. With a Personal access token, it is every root project the token holder
is enabled for, plus their subprojects.

Filter by name when locating a project, or use [Retrieve a project](/docs/apis/rest/projects/get-project) when you already have its ID. Integrations built around Compatibility API Account SIDs can use [List accounts](/docs/compatibility-api/rest/accounts/list-accounts) instead.

#### Permissions

With a project API token, the token must have the following scope(s) enabled to make a successful request: _Management_.

With a [Personal access token](/docs/apis/authorization#personal-access-tokens) there are no scopes. The token holder must be an owner or admin of the space, and the request reaches only the projects the holder is enabled for, plus their subprojects.

[Learn more about API scopes](/docs/platform/your-signalwire-api-space).

Reference: https://signalwire.com/docs/apis/rest/projects/list-projects

## Authentication

- `Authorization` header (basic auth, required) — SignalWire Basic Authentication using Project ID and API Token. The client sends HTTP requests with the Authorization header containing the word Basic followed by a space and a base64-encoded string of project_id:token. The project ID will be used as the username and the API token as the password. Example: ``` Authorization: Basic base64(project_id:token) ```
- `Authorization` header (basic auth, required) — Personal access token authentication for space-wide administration. Send HTTP Basic auth with an empty username and the Personal access token as the password. A Personal access token carries your own authority rather than a project's: it is created from your user menu in the Dashboard, is prefixed `pat_`, and has no scopes. The holder must be an owner or admin of the space named by the subdomain, and the token acts only on that space. Example: ``` Authorization: Basic base64(:pat_...) ```

## Request

### Query parameters

- `name` (string, optional) — Filter projects by name.
- `page_size` (integer, optional, default: 50) — The number of results per page.
- `page_token` (string, optional) — Cursor token for paging, taken from the `links` in a previous response.
- `page_number` (integer, optional, default: 0) — The page index, used together with `page_token`.

## Response

### 200

The request has succeeded.

- `links` (Projects.ProjectPaginationLinks, required) — Pagination links for the list of projects.
- `data` (list of Projects.Project, required) — The projects on this page.

## Errors

### 401 Unauthorized Error

Access is unauthorized.

- `error` (enum, required)
  - Allowed values: `Unauthorized`

### 500 Internal Server Error

An internal server error occurred.

- `error` (enum, required)
  - Allowed values: `Internal Server Error`

## Types

### Projects.ProjectPaginationLinks

Pagination links for a list of projects.

- `self` (string, required) — The link to the current page.
- `first` (string, required) — The link to the first page.
- `next` (string, optional) — The link to the next page. Only present when more results exist.
- `prev` (string, optional) — The link to the previous page. Only present when a previous page exists.

### Projects.Project

A project or subproject within the caller's project tree.

- `id` (string, required) — The unique identifier of the project.
- `name` (string, required) — The name of the project.
- `parent_project_id` (string, required, nullable) — The unique identifier of the root project. `null` when this project is itself a root project.
- `subproject` (boolean, required) — `true` when this project is a subproject.
- `region_preference` (string, required) — The effective region preference for the project. Returned in all responses; it is not currently settable through this API.
- `protect_recordings` (boolean, required) — When enabled, recordings created within the project require authentication to access.
- `protect_message_media` (boolean, required) — When enabled, message media created within the project requires authentication to access.
- `protect_fax_media` (boolean, required) — When enabled, fax media created within the project requires authentication to access.
- `force_https_requests` (boolean, required) — When enabled, requests made to the project's webhooks and callbacks must use HTTPS.
- `created_at` (datetime, required) — The date and time when the project was created.
- `updated_at` (datetime, required) — The date and time when the project was last updated.

## Examples

**Response**

```json
{
  "links": {
    "self": "https://example-space.signalwire.com/api/projects?page_size=50",
    "first": "https://example-space.signalwire.com/api/projects?page_size=50",
    "next": "https://example-space.signalwire.com/api/projects?page_size=50&page_number=1&page_token=PA8f14e45f",
    "prev": "https://example-space.signalwire.com/api/projects?page_size=50&page_number=0&page_token=PA8f14e45f"
  },
  "data": [
    {
      "id": "8f14e45f-ceea-467d-9c2b-7a1d3a9b2c34",
      "name": "Acme Staging",
      "parent_project_id": "b3877739-5c7e-4d4f-9d1a-2f0c8c2f1a11",
      "subproject": true,
      "region_preference": "us-west",
      "protect_recordings": false,
      "protect_message_media": false,
      "protect_fax_media": false,
      "force_https_requests": true,
      "created_at": "2024-05-06T12:20:00Z",
      "updated_at": "2024-05-06T12:20:00Z"
    }
  ]
}
```

**SDK Code**

```python
import requests

url = "https://{your_space_name}.signalwire.com/api/projects"

response = requests.get(url, auth=("<project_id>", "<api_token>"))

print(response.json())
```

```javascript
const url = 'https://{your_space_name}.signalwire.com/api/projects';
const credentials = btoa("<project_id>:<api_token>");

const options = {method: 'GET', headers: {Authorization: `Basic ${credentials}`}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://{your_space_name}.signalwire.com/api/projects"

	req, _ := http.NewRequest("GET", url, nil)

	req.SetBasicAuth("<project_id>", "<api_token>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby
require 'uri'
require 'net/http'

url = URI("https://{your_space_name}.signalwire.com/api/projects")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request.basic_auth("<project_id>", "<api_token>")

response = http.request(request)
puts response.read_body
```

```java
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://{your_space_name}.signalwire.com/api/projects")
  .basicAuth("<project_id>", "<api_token>")
  .asString();
```

```php
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://{your_space_name}.signalwire.com/api/projects', [
  'headers' => [
  ],
    'auth' => ['<project_id>', '<api_token>'],
]);

echo $response->getBody();
```

```csharp
using RestSharp;
using RestSharp.Authenticators;

var client = new RestClient("https://{your_space_name}.signalwire.com/api/projects");
client.Authenticator = new HttpBasicAuthenticator("<project_id>", "<api_token>");
var request = new RestRequest(Method.GET);

IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let credentials = Data("<project_id>:<api_token>".utf8).base64EncodedString()

let headers = ["Authorization": "Basic \(credentials)"]

let request = NSMutableURLRequest(url: NSURL(string: "https://{your_space_name}.signalwire.com/api/projects")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```